Stop using callbacks in MemoryCoordinatorProxy

content/browser/memory/memory_coordinator_impl.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/memory/memory_coordinator_impl.h"
 
 #include "base/metrics/histogram_macros.h"
 #include "base/process/process_metrics.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 174 matching lines @@
 void MemoryCoordinatorImpl::OnChildAdded(int render_process_id) {
   // Populate the global state as an initial state of a newly created process.
   auto new_state = ToMojomMemoryState(GetGlobalMemoryState());
   SetChildMemoryState(render_process_id, new_state);
 }
 
 base::MemoryState MemoryCoordinatorImpl::GetGlobalMemoryState() const {
   return current_state_;
 }
 
-base::MemoryState MemoryCoordinatorImpl::GetCurrentMemoryState() const {
+base::WeakPtr<base::MemoryCoordinatorInterface>
+MemoryCoordinatorImpl::GetWeakPtr() {
+  return weak_ptr_factory_.GetWeakPtr();
+}
+
+base::MemoryState MemoryCoordinatorImpl::GetLocalMemoryState() {
   // SUSPENDED state may not make sense to the browser process. Use THROTTLED
   // instead when the global state is SUSPENDED.
   // TODO(bashi): Maybe worth considering another state for the browser.
   return current_state_ == MemoryState::SUSPENDED ? MemoryState::THROTTLED
                                                   : current_state_;
 }
 
-void MemoryCoordinatorImpl::SetCurrentMemoryStateForTesting(
+void MemoryCoordinatorImpl::SetMemoryStateForTesting(
     base::MemoryState memory_state) {
   // This changes the current state temporariy for testing. The state will be
   // updated 1 minute later.
   ForceSetGlobalState(memory_state, base::TimeDelta::FromMinutes(1));
 }
 
 void MemoryCoordinatorImpl::ForceSetGlobalState(base::MemoryState new_state,
                                                 base::TimeDelta duration) {
   DCHECK(new_state != MemoryState::UNKNOWN);
   ChangeStateIfNeeded(current_state_, new_state);
@@ skipping 80 matching lines @@
 void MemoryCoordinatorImpl::UpdateState() {
   MemoryState next_state = CalculateNextState();
   if (ChangeStateIfNeeded(current_state_, next_state)) {
     ScheduleUpdateState(minimum_transition_period_);
   } else {
     ScheduleUpdateState(monitoring_interval_);
   }
 }
 
 void MemoryCoordinatorImpl::NotifyStateToClients() {
-  auto state = GetCurrentMemoryState();
+  auto state = GetLocalMemoryState();
   base::MemoryCoordinatorClientRegistry::GetInstance()->Notify(state);
 }
 
 void MemoryCoordinatorImpl::NotifyStateToChildren() {
   auto mojo_state = ToMojomMemoryState(current_state_);
   // It's OK to call SetChildMemoryState() unconditionally because it checks
   // whether this state transition is valid.
   for (auto& iter : children())
     SetChildMemoryState(iter.first, mojo_state);
 }
@@ skipping 66 matching lines @@
 }
 
 bool MemoryCoordinatorImpl::ValidateParameters() {
   return (new_renderers_until_throttled_ > new_renderers_until_suspended_) &&
       (new_renderers_back_to_normal_ > new_renderers_back_to_throttled_) &&
       (new_renderers_back_to_normal_ > new_renderers_until_throttled_) &&
       (new_renderers_back_to_throttled_ > new_renderers_until_suspended_);
 }
 
 }  // namespace content