Switch from Delegate to Observer.

components/arc/arc_bridge_bootstrap.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_bridge_bootstrap.h"
 
 #include <fcntl.h>
 #include <grp.h>
 #include <poll.h>
 #include <unistd.h>
 
 #include <utility>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/sys_info.h"
 #include "base/task_runner_util.h"
 #include "base/threading/thread_checker.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/threading/worker_pool.h"
 #include "chromeos/cryptohome/cryptohome_parameters.h"
 #include "chromeos/dbus/dbus_method_call_status.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/session_manager_client.h"
+#include "components/arc/arc_bridge_host_impl.h"
 #include "components/user_manager/user_manager.h"
 #include "ipc/unix_domain_socket_util.h"
 #include "mojo/edk/embedder/embedder.h"
 #include "mojo/edk/embedder/platform_channel_pair.h"
 #include "mojo/edk/embedder/platform_channel_utils_posix.h"
 #include "mojo/edk/embedder/platform_handle_vector.h"
 #include "mojo/edk/embedder/scoped_platform_handle.h"
 #include "mojo/public/cpp/bindings/binding.h"
 
 namespace arc {
@@ skipping 79 matching lines @@
   // CREATING_SOCKET
   //   CreateSocket() -> OnSocketCreated() ->
   // STARTING_INSTANCE
   //   -> OnInstanceStarted() ->
   // CONNECTING_MOJO
   //   ConnectMojo() -> OnMojoConnected() ->
   // RUNNING
   //
   // At any state, Stop() can be called. It does not immediately stop the
   // instance, but will eventually stop it.
-  // The actual stop will be notified via OnStopped() of the |delegate_|.
+  // The actual stop will be notified via Observer::OnStopped().
   //
   // When Stop() is called, it makes various behavior based on the current
   // phase.
   //
   // NOT_STARTED:
   //   Do nothing. Immediately transition to the STOPPED state.
   // CHECKING_DISK_SPACE, CREATING_SOCKET:
   //   The main task of those phases runs on WorkerPool thread. So, Stop()
   //   just sets the flag and return. On the main task completion, a callback
   //   will run on the main (practically UI) thread, and the flag is checked
@@ skipping 101 matching lines @@
   // The state of the bootstrap connection.
   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_;
+
   base::ThreadChecker thread_checker_;
 
   // WeakPtrFactory to use callbacks.
   base::WeakPtrFactory<ArcBridgeBootstrapImpl> weak_factory_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ArcBridgeBootstrapImpl);
 };
 
 ArcBridgeBootstrapImpl::ArcBridgeBootstrapImpl()
     : weak_factory_(this) {
   chromeos::SessionManagerClient* client = GetSessionManagerClient();
   if (client == nullptr)
     return;
   client->AddObserver(this);
 }
 
 ArcBridgeBootstrapImpl::~ArcBridgeBootstrapImpl() {
   DCHECK(thread_checker_.CalledOnValidThread());
   // TODO(hidehiko): CHECK if |state_| is in NOT_STARTED or STOPPED.
   // Currently, specifically on shutdown, the state_ can be any value.
   chromeos::SessionManagerClient* client = GetSessionManagerClient();
   if (client == nullptr)
     return;
   client->RemoveObserver(this);
 }
 
 void ArcBridgeBootstrapImpl::Start() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(delegate_);
   DCHECK_EQ(state_, State::NOT_STARTED);
   VLOG(2) << "Starting ARC session.";
   VLOG(2) << "Checking disk space...";
   state_ = State::CHECKING_DISK_SPACE;
 
   // TODO(crbug.com/628124): Move disk space checking logic to session_manager.
   base::PostTaskAndReplyWithResult(
       base::WorkerPool::GetTaskRunner(true).get(), FROM_HERE,
       base::Bind(&base::SysInfo::AmountOfFreeDiskSpace,
                  base::FilePath(kDiskCheckPath)),
@@ skipping 212 matching lines @@
       mojo::edk::ScopedPlatformHandle(mojo::edk::PlatformHandle(fd.release())));
   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));
-  // TODO(hidehiko): Move to creating ArcBridgeHost here to fix the twisted
-  // state change.
+  arc_bridge_host_.reset(new ArcBridgeHostImpl(std::move(instance)));
 
   VLOG(2) << "Mojo is connected. ARC is running.";
   state_ = State::RUNNING;
-  delegate_->OnConnectionEstablished(std::move(instance));
+  FOR_EACH_OBSERVER(ArcBridgeBootstrap::Observer, observer_list_, OnReady());
 }
 
 void ArcBridgeBootstrapImpl::Stop() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(delegate_);
   VLOG(2) << "Stopping ARC session is requested.";
 
   // For second time or later, just do nothing.
   // It is already in the stopping phase.
   if (stop_requested_)
     return;
 
   stop_requested_ = true;
+  arc_bridge_host_.reset();
   switch (state_) {
     case State::NOT_STARTED:
       OnStopped(ArcBridgeService::StopReason::SHUTDOWN);
       return;
 
     case State::CHECKING_DISK_SPACE:
     case State::CREATING_SOCKET:
     case State::STARTING_INSTANCE:
       // Before starting the ARC instance, we do nothing here.
       // At some point, a callback will be invoked on UI thread,
@@ skipping 64 matching lines @@
     reason = ArcBridgeService::StopReason::CRASH;
   }
   OnStopped(reason);
 }
 
 void ArcBridgeBootstrapImpl::OnStopped(ArcBridgeService::StopReason reason) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // OnStopped() should be called once per instance.
   DCHECK_NE(state_, State::STOPPED);
   VLOG(2) << "ARC session is stopped.";
+  arc_bridge_host_.reset();
   state_ = State::STOPPED;
-  delegate_->OnStopped(reason);
+  FOR_EACH_OBSERVER(ArcBridgeBootstrap::Observer, observer_list_,
+                    OnStopped(reason));
 }
 
 }  // namespace
 
+ArcBridgeBootstrap::ArcBridgeBootstrap() = default;
+ArcBridgeBootstrap::~ArcBridgeBootstrap() = default;
+
+void ArcBridgeBootstrap::AddObserver(Observer* observer) {
+  observer_list_.AddObserver(observer);
+}
+
+void ArcBridgeBootstrap::RemoveObserver(Observer* observer) {
+  observer_list_.RemoveObserver(observer);
+}
+
 // static
 std::unique_ptr<ArcBridgeBootstrap> ArcBridgeBootstrap::Create() {
   return base::MakeUnique<ArcBridgeBootstrapImpl>();
 }
 
 }  // namespace arc