Migrate ArcService to BrowserContextKeyedService part 17.

This CL migrates ArcProcessService.

BUG=672829
TEST=Ran try.

Change-Id: Ia1b34a32eba2e8c3c069dcca9e89712e2e1396a2
Reviewed-on: https://chromium-review.googlesource.com/572445
Commit-Queue: Hidehiko Abe <hidehiko@chromium.org>
Reviewed-by: Luis Hector Chavez <lhchavez@chromium.org>
Cr-Commit-Position: refs/heads/master@{#487175}

chrome/browser/chromeos/arc/arc_service_launcher.cc

@@ -96,8 +96,6 @@ void ArcServiceLauncher::Initialize() {
   // List in lexicographical order.
   arc_service_manager_->AddService(
       base::MakeUnique<ArcIntentHelperBridge>(arc_bridge_service));
-  arc_service_manager_->AddService(
-      base::MakeUnique<ArcProcessService>(arc_bridge_service));
   arc_service_manager_->AddService(
       base::MakeUnique<ArcSettingsService>(arc_bridge_service));
   arc_service_manager_->AddService(
@@ -183,6 +181,7 @@ void ArcServiceLauncher::OnPrimaryUserProfilePrepared(Profile* profile) {
   ArcPolicyBridge::GetForBrowserContext(profile);
   ArcPowerBridge::GetForBrowserContext(profile);
   ArcPrintService::GetForBrowserContext(profile);
+  ArcProcessService::GetForBrowserContext(profile);
   ArcProvisionNotificationService::GetForBrowserContext(profile);
   ArcTracingBridge::GetForBrowserContext(profile);
 

chrome/browser/chromeos/arc/process/arc_process_service.cc

@@ -18,12 +18,14 @@
 
 #include "base/callback.h"
 #include "base/logging.h"
+#include "base/memory/singleton.h"
 #include "base/process/process.h"
 #include "base/process/process_iterator.h"
 #include "base/task_runner_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/trace_event/trace_event.h"
 #include "components/arc/arc_bridge_service.h"
+#include "components/arc/arc_browser_context_keyed_service_factory_base.h"
 #include "content/public/browser/browser_thread.h"
 
 namespace arc {
@@ -35,8 +37,6 @@ using std::vector;
 
 namespace {
 
-// Weak pointer.  This class is owned by ArcServiceManager.
-ArcProcessService* g_arc_process_service = nullptr;
 static constexpr char kInitName[] = "/init";
 static constexpr bool kNotFocused = false;
 static constexpr int64_t kNoActivityTimeInfo = 0L;
@@ -200,10 +200,36 @@ void Reset(scoped_refptr<ArcProcessService::NSPidToPidMap> pid_map) {
     pid_map->clear();
 }
 
+// Singleton factory for ArcProcessService.
+class ArcProcessServiceFactory
+    : public internal::ArcBrowserContextKeyedServiceFactoryBase<
+          ArcProcessService,
+          ArcProcessServiceFactory> {
+ public:
+  // Factory name used by ArcBrowserContextKeyedServiceFactoryBase.
+  static constexpr const char* kName = "ArcProcessServiceFactory";
+
+  static ArcProcessServiceFactory* GetInstance() {
+    return base::Singleton<ArcProcessServiceFactory>::get();
+  }
+
+ private:
+  friend base::DefaultSingletonTraits<ArcProcessServiceFactory>;
+  ArcProcessServiceFactory() = default;
+  ~ArcProcessServiceFactory() override = default;
+};
+
 }  // namespace
 
-ArcProcessService::ArcProcessService(ArcBridgeService* bridge_service)
-    : ArcService(bridge_service),
+// static
+ArcProcessService* ArcProcessService::GetForBrowserContext(
+    content::BrowserContext* context) {
+  return ArcProcessServiceFactory::GetForBrowserContext(context);
+}
+
+ArcProcessService::ArcProcessService(content::BrowserContext* context,
+                                     ArcBridgeService* bridge_service)
+    : arc_bridge_service_(bridge_service),
       nspid_to_pid_(new NSPidToPidMap()),
       weak_ptr_factory_(this) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
@@ -211,21 +237,30 @@ ArcProcessService::ArcProcessService(ArcBridgeService* bridge_service)
   task_runner_ = blocking_pool->GetSequencedTaskRunnerWithShutdownBehavior(
       blocking_pool->GetSequenceToken(),
       base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
-  arc_bridge_service()->process()->AddObserver(this);
-  DCHECK(!g_arc_process_service);
-  g_arc_process_service = this;
+  arc_bridge_service_->process()->AddObserver(this);
 }
 
 ArcProcessService::~ArcProcessService() {
-  DCHECK(g_arc_process_service == this);
-  g_arc_process_service = nullptr;
-  arc_bridge_service()->process()->RemoveObserver(this);
+  // TODO(hidehiko): Currently, the lifetime of ArcBridgeService and
+  // BrowserContextKeyedService is not nested.
+  // If ArcServiceManager::Get() returns nullptr, it is already destructed,
+  // so do not touch it.
+  if (ArcServiceManager::Get())
+    arc_bridge_service_->process()->RemoveObserver(this);
 }
 
 // static
 ArcProcessService* ArcProcessService::Get() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  return g_arc_process_service;
+  // This is called from TaskManager implementation, which is isolated
+  // from BrowserContext.
+  // Use ArcServiceManager's BrowserContext instance, since 1) it is always
+  // allowed to use ARC, and 2) the rest of ARC service's lifetime are
+  // tied to it.
+  auto* arc_service_manager = ArcServiceManager::Get();
+  if (!arc_service_manager || !arc_service_manager->browser_context())
+    return nullptr;
+  return GetForBrowserContext(arc_service_manager->browser_context());
 }
 
 void ArcProcessService::RequestSystemProcessList(
@@ -249,7 +284,7 @@ bool ArcProcessService::RequestAppProcessList(
     return false;
 
   mojom::ProcessInstance* process_instance = ARC_GET_INSTANCE_FOR_METHOD(
-      arc_bridge_service()->process(), RequestProcessList);
+      arc_bridge_service_->process(), RequestProcessList);
   if (!process_instance)
     return false;
 

chrome/browser/chromeos/arc/process/arc_process_service.h

@@ -15,9 +15,13 @@
 #include "base/process/process_iterator.h"
 #include "base/sequenced_task_runner.h"
 #include "chrome/browser/chromeos/arc/process/arc_process.h"
-#include "components/arc/arc_service.h"
 #include "components/arc/common/process.mojom.h"
 #include "components/arc/instance_holder.h"
+#include "components/keyed_service/core/keyed_service.h"
+
+namespace content {
+class BrowserContext;
+}  // namespace content
 
 namespace arc {
 
@@ -46,13 +50,19 @@ class ArcBridgeService;
 // as System Process. RequestAppProcessList() is responsible for app processes
 // while RequestSystemProcessList() is responsible for System Processes.
 class ArcProcessService
-    : public ArcService,
+    : public KeyedService,
       public InstanceHolder<mojom::ProcessInstance>::Observer {
  public:
+  // Returns singleton instance for the given BrowserContext,
+  // or nullptr if the browser |context| is not allowed to use ARC.
+  static ArcProcessService* GetForBrowserContext(
+      content::BrowserContext* context);
+
   using RequestProcessListCallback =
       base::Callback<void(std::vector<ArcProcess>)>;
 
-  explicit ArcProcessService(ArcBridgeService* bridge_service);
+  ArcProcessService(content::BrowserContext* context,
+                    ArcBridgeService* bridge_service);
   ~ArcProcessService() override;
 
   // Returns nullptr before the global instance is ready.
@@ -101,6 +111,8 @@ class ArcProcessService
   void OnInstanceReady() override;
   void OnInstanceClosed() override;
 
+  ArcBridgeService* const arc_bridge_service_;  // Owned by ArcServiceManager.
+
   // Whether ARC is ready to request its process list.
   bool instance_ready_ = false;