arc: Revamp the ArcBridgeService interface

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 <algorithm>
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 266 matching lines @@
 int TabManagerDelegate::MemoryStat::EstimatedMemoryFreedKB(
     base::ProcessHandle pid) {
   std::unique_ptr<base::ProcessMetrics> process_metrics(
       base::ProcessMetrics::CreateProcessMetrics(pid));
   base::WorkingSetKBytes mem_usage;
   process_metrics->GetWorkingSetKBytes(&mem_usage);
   return mem_usage.priv;
 }
 
 class TabManagerDelegate::UmaReporter {
-  public:
-   UmaReporter()
-       : last_kill_time_(), total_kills_(0) {}
-   ~UmaReporter() {}
-   void ReportKill(const int memory_freed);
+ public:
+  UmaReporter() : last_kill_time_(), total_kills_(0) {}
+  ~UmaReporter() {}
+  void ReportKill(const int memory_freed);
 
-  private:
-   base::Time last_kill_time_;
-   int total_kills_;
+ private:
+  base::Time last_kill_time_;
+  int total_kills_;
 };
 
 void TabManagerDelegate::UmaReporter::ReportKill(const int memory_freed) {
   base::Time now = base::Time::Now();
   const TimeDelta time_delta =
       last_kill_time_.is_null() ?
       TimeDelta::FromSeconds(arc::kMaxOomMemoryKillTimeDeltaSecs) :
       (now - last_kill_time_);
   UMA_HISTOGRAM_OOM_KILL_TIME_INTERVAL(
             "Arc.LowMemoryKiller.TimeDelta", time_delta);
@@ skipping 23 matching lines @@
       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->AddObserver(this);
+    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->RemoveObserver(this);
+    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::OnProcessInstanceReady() {
+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();
+  arc_process_instance_ = arc_bridge_service->process()->instance();
+  arc_process_instance_version_ = arc_bridge_service->process()->version();
 
   DCHECK(arc_process_instance_);
 
   if (!IsArcMemoryManagementEnabled())
     return;
 
   if (arc_process_instance_version_ < 2) {
     VLOG(1) << "ProcessInstance version < 2 does not "
                "support DisableBuiltinOomAdjustment() yet.";
     return;
   }
   // Stop Android system-wide oom_adj adjustment since this class will
   // take over oom_score_adj settings.
   arc_process_instance_->DisableBuiltinOomAdjustment();
 
   if (arc_process_instance_version_ < 3) {
     VLOG(1) << "arc::ProcessInstance version < 3 does not "
                "support DisableLowMemoryKiller() yet.";
     return;
   }
   VLOG(2) << "Disable LowMemoryKiller";
   arc_process_instance_->DisableLowMemoryKiller();
 }
 
-void TabManagerDelegate::OnProcessInstanceClosed() {
+void TabManagerDelegate::OnInstanceClosed() {
   arc_process_instance_ = nullptr;
   arc_process_instance_version_ = 0;
 }
 
 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 403 matching lines @@
       }
     }
     priority += priority_increment;
   }
 
   if (oom_score_for_tabs.size())
     SetOomScoreAdjForTabs(oom_score_for_tabs);
 }
 
 }  // namespace memory