Always use arc::InstanceHolder<T>::GetInstanceForMethod

chrome/browser/memory/tab_manager_delegate_chromeos.cc

 // Copyright 2015 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 "chrome/browser/memory/tab_manager_delegate_chromeos.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <map>
@@ skipping 45 matching lines @@
 
 const char kExoShellSurfaceWindowName[] = "ExoShellSurface";
 const char kArcProcessNamePrefix[] = "org.chromium.arc.";
 
 // When switching to a new tab the tab's renderer's OOM score needs to be
 // updated to reflect its front-most status and protect it from discard.
 // However, doing this immediately might slow down tab switch time, so wait
 // a little while before doing the adjustment.
 const int kFocusedProcessScoreAdjustIntervalMs = 500;
 
+const uint32_t kMinVersionForKillProcess = 1;
+
 aura::client::ActivationClient* GetActivationClient() {
   if (!ash::Shell::HasInstance())
     return nullptr;
   return aura::client::GetActivationClient(ash::Shell::GetPrimaryRootWindow());
 }
 
 // Checks if a window renders ARC apps.
 bool IsArcWindow(aura::Window* window) {
   if (!window || window->name() != kExoShellSurfaceWindowName)
     return false;
@@ skipping 229 matching lines @@
     const base::WeakPtr<TabManager>& tab_manager)
   : TabManagerDelegate(tab_manager, new MemoryStat()) {
 }
 
 TabManagerDelegate::TabManagerDelegate(
     const base::WeakPtr<TabManager>& tab_manager,
     TabManagerDelegate::MemoryStat* mem_stat)
     : tab_manager_(tab_manager),
       focused_process_(new FocusedProcess()),
       mem_stat_(mem_stat),
-      arc_process_instance_(nullptr),
-      arc_process_instance_version_(0),
       uma_(new UmaReporter()),
       weak_ptr_factory_(this) {
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this, content::NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED,
                  content::NotificationService::AllBrowserContextsAndSources());
-  auto* arc_bridge_service = arc::ArcBridgeService::Get();
-  if (arc_bridge_service)
-    arc_bridge_service->process()->AddObserver(this);
   auto* activation_client = GetActivationClient();
   if (activation_client)
     activation_client->AddObserver(this);
   BrowserList::GetInstance()->AddObserver(this);
 }
 
 TabManagerDelegate::~TabManagerDelegate() {
   BrowserList::GetInstance()->RemoveObserver(this);
   auto* activation_client = GetActivationClient();
   if (activation_client)
     activation_client->RemoveObserver(this);
-  auto* arc_bridge_service = arc::ArcBridgeService::Get();
-  if (arc_bridge_service)
-    arc_bridge_service->process()->RemoveObserver(this);
 }
 
 void TabManagerDelegate::OnBrowserSetLastActive(Browser* browser) {
   // Set OOM score to the selected tab when a browser window is activated.
   // content::NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED didn't catch the
   // case (like when switching focus between 2 browser windows) so we need to
   // handle it here.
   TabStripModel* tab_strip_model = browser->tab_strip_model();
   int selected_index = tab_strip_model->active_index();
   content::WebContents* contents =
       tab_strip_model->GetWebContentsAt(selected_index);
   if (!contents)
     return;
 
   base::ProcessHandle pid = contents->GetRenderProcessHost()->GetHandle();
   AdjustFocusedTabScore(pid);
 }
 
-void TabManagerDelegate::OnInstanceReady() {
-  auto* arc_bridge_service = arc::ArcBridgeService::Get();
-  DCHECK(arc_bridge_service);
-
-  arc_process_instance_ = arc_bridge_service->process()->instance();
-  arc_process_instance_version_ = arc_bridge_service->process()->version();
-
-  DCHECK(arc_process_instance_);
-}
-
-void TabManagerDelegate::OnInstanceClosed() {
-  arc_process_instance_ = nullptr;
-  arc_process_instance_version_ = 0;
-}
-
 // TODO(cylee): Remove this function if Android process OOM score settings
 // is moved back to Android.
 // For example, negotiate non-overlapping OOM score ranges so Chrome and Android
 // can set OOM score for processes in their own world.
 void TabManagerDelegate::OnWindowActivated(
     aura::client::ActivationChangeObserver::ActivationReason reason,
     aura::Window* gained_active,
     aura::Window* lost_active) {
   if (IsArcWindow(gained_active)) {
     // Currently there is no way to know which app is displayed in the ARC
@@ skipping 205 matching lines @@
     candidates.emplace_back(&app);
   }
 
   // Sort candidates according to priority.
   std::sort(candidates.begin(), candidates.end());
 
   return candidates;
 }
 
 bool TabManagerDelegate::KillArcProcess(const int nspid) {
-  if (!arc_process_instance_)
+  auto* arc_bridge_service = arc::ArcBridgeService::Get();
+  if (!arc_bridge_service)
     return false;
-  arc_process_instance_->KillProcess(nspid, "LowMemoryKill");
+
+  auto* arc_process_instance =
+      arc_bridge_service->process()->GetInstanceForMethod(
+          "KillProcess", kMinVersionForKillProcess);
+  if (!arc_process_instance)
+    return false;
+
+  arc_process_instance->KillProcess(nspid, "LowMemoryKill");
   return true;
 }
 
 bool TabManagerDelegate::KillTab(int64_t tab_id) {
   // Check |tab_manager_| is alive before taking tabs into consideration.
   return tab_manager_ &&
       tab_manager_->CanDiscardTab(tab_id) &&
       tab_manager_->DiscardTabById(tab_id);
 }
 
@@ skipping 147 matching lines @@
     }
     priority += priority_increment;
   }
 
   if (oom_scores_to_change.size())
     GetDebugDaemonClient()->SetOomScoreAdj(
         oom_scores_to_change, base::Bind(&OnSetOomScoreAdj));
 }
 
 }  // namespace memory