Remove explicit singletonness of ArcBridgeService part 1.

components/arc/arc_session.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 "components/arc/arc_session.h"
 
 #include <fcntl.h>
 #include <grp.h>
 #include <poll.h>
 #include <unistd.h>
@@ skipping 181 matching lines @@
     // The instance has started. Waiting for it to connect to the IPC bridge.
     CONNECTING_MOJO,
 
     // The instance is fully set up.
     RUNNING,
 
     // ARC is terminated.
     STOPPED,
   };
 
-  explicit ArcSessionImpl(
-      const scoped_refptr<base::TaskRunner>& blocking_task_runner);
+  ArcSessionImpl(ArcBridgeService* arc_bridge_service,
+                 const scoped_refptr<base::TaskRunner>& blocking_task_runner);
   ~ArcSessionImpl() override;
 
   // ArcSession overrides:
   void Start() override;
   void Stop() override;
   void OnShutdown() override;
 
  private:
   // Creates the UNIX socket on a worker pool and then processes its file
   // descriptor.
@@ skipping 17 matching lines @@
   // chromeos::SessionManagerClient::Observer:
   void ArcInstanceStopped(bool clean) override;
 
   // Completes the termination procedure.
   void OnStopped(ArcBridgeService::StopReason reason);
 
   // Checks whether a function runs on the thread where the instance is
   // created.
   base::ThreadChecker thread_checker_;
 
+  // Owned by ArcServiceManager.
+  ArcBridgeService* const arc_bridge_service_;
+
   // Task runner to run a blocking tasks.
   scoped_refptr<base::TaskRunner> blocking_task_runner_;
 
   // The state of the session.
   State state_ = State::NOT_STARTED;
 
   // When Stop() is called, this flag is set.
   bool stop_requested_ = false;
 
   // In CONNECTING_MOJO state, this is set to the write side of the pipe
   // to notify cancelling of the procedure.
   base::ScopedFD accept_cancel_pipe_;
 
   // Mojo endpoint.
   std::unique_ptr<mojom::ArcBridgeHost> arc_bridge_host_;
 
   // WeakPtrFactory to use callbacks.
   base::WeakPtrFactory<ArcSessionImpl> weak_factory_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ArcSessionImpl);
 };
 
 ArcSessionImpl::ArcSessionImpl(
+    ArcBridgeService* arc_bridge_service,
     const scoped_refptr<base::TaskRunner>& blocking_task_runner)
-    : blocking_task_runner_(blocking_task_runner), weak_factory_(this) {
+    : arc_bridge_service_(arc_bridge_service),
+      blocking_task_runner_(blocking_task_runner),
+      weak_factory_(this) {
   chromeos::SessionManagerClient* client = GetSessionManagerClient();
   if (client == nullptr)
     return;
   client->AddObserver(this);
 }
 
 ArcSessionImpl::~ArcSessionImpl() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(state_ == State::NOT_STARTED || state_ == State::STOPPED);
   chromeos::SessionManagerClient* client = GetSessionManagerClient();
@@ skipping 203 matching lines @@
       mojo::edk::CreateMessagePipe(std::move(fd));
   if (!server_pipe.is_valid()) {
     LOG(ERROR) << "Invalid pipe";
     StopArcInstance();
     return;
   }
 
   mojom::ArcBridgeInstancePtr instance;
   instance.Bind(mojo::InterfacePtrInfo<mojom::ArcBridgeInstance>(
       std::move(server_pipe), 0u));
-  arc_bridge_host_.reset(new ArcBridgeHostImpl(std::move(instance)));
+  arc_bridge_host_ = base::MakeUnique<ArcBridgeHostImpl>(arc_bridge_service_,
+                                                         std::move(instance));
 
   VLOG(2) << "Mojo is connected. ARC is running.";
   state_ = State::RUNNING;
   for (auto& observer : observer_list_)
     observer.OnReady();
 }
 
 void ArcSessionImpl::Stop() {
   DCHECK(thread_checker_.CalledOnValidThread());
   VLOG(2) << "Stopping ARC session is requested.";
@@ skipping 125 matching lines @@
 void ArcSession::AddObserver(Observer* observer) {
   observer_list_.AddObserver(observer);
 }
 
 void ArcSession::RemoveObserver(Observer* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
 // static
 std::unique_ptr<ArcSession> ArcSession::Create(
+    ArcBridgeService* arc_bridge_service,
     const scoped_refptr<base::TaskRunner>& blocking_task_runner) {
-  return base::MakeUnique<ArcSessionImpl>(blocking_task_runner);
+  return base::MakeUnique<ArcSessionImpl>(arc_bridge_service,
+                                          blocking_task_runner);
 }
 
 }  // namespace arc