Migrate ArcBridgeService::Observer and ArcSession::Observer.

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>
 
 #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 "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/arc/arc_features.h"
+#include "components/arc/arc_session_observer.h"
 #include "components/user_manager/user_manager.h"
 #include "mojo/edk/embedder/embedder.h"
 #include "mojo/edk/embedder/named_platform_handle.h"
 #include "mojo/edk/embedder/named_platform_handle_utils.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"
 
@@ skipping 77 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 Observer::OnStopped().
+  // The actual stop will be notified via ArcSessionObserver::OnStopped().
   //
   // When Stop() is called, it makes various behavior based on the current
   // phase.
   //
   // NOT_STARTED:
   //   Do nothing. Immediately transition to the STOPPED state.
   // CREATING_SOCKET:
   //   The main task of the phase runs on BlockingPool 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 87 matching lines @@
       base::ScopedFD cancel_fd);
   void OnMojoConnected(mojo::edk::ScopedPlatformHandle fd);
 
   // Request to stop ARC instance via DBus.
   void StopArcInstance();
 
   // chromeos::SessionManagerClient::Observer:
   void ArcInstanceStopped(bool clean) override;
 
   // Completes the termination procedure.
-  void OnStopped(ArcBridgeService::StopReason reason);
+  void OnStopped(ArcSessionObserver::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_;
@@ skipping 90 matching lines @@
   return socket_fd;
 }
 
 void ArcSessionImpl::OnSocketCreated(
     mojo::edk::ScopedPlatformHandle socket_fd) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(state_, State::CREATING_SOCKET);
 
   if (stop_requested_) {
     VLOG(1) << "Stop() called while connecting";
-    OnStopped(ArcBridgeService::StopReason::SHUTDOWN);
+    OnStopped(ArcSessionObserver::StopReason::SHUTDOWN);
     return;
   }
 
   if (!socket_fd.is_valid()) {
     LOG(ERROR) << "ARC: Error creating socket";
-    OnStopped(ArcBridgeService::StopReason::GENERIC_BOOT_FAILURE);
+    OnStopped(ArcSessionObserver::StopReason::GENERIC_BOOT_FAILURE);
     return;
   }
 
   VLOG(2) << "Socket is created. Starting ARC instance...";
   state_ = State::STARTING_INSTANCE;
   user_manager::UserManager* user_manager = user_manager::UserManager::Get();
   DCHECK(user_manager->GetPrimaryUser());
   const cryptohome::Identification cryptohome_id(
       user_manager->GetPrimaryUser()->GetAccountId());
 
@@ skipping 20 matching lines @@
   }
 
   DCHECK_EQ(state_, State::STARTING_INSTANCE);
 
   if (stop_requested_) {
     if (result == StartArcInstanceResult::SUCCESS) {
       // The ARC instance has started to run. Request to stop.
       StopArcInstance();
       return;
     }
-    OnStopped(ArcBridgeService::StopReason::SHUTDOWN);
+    OnStopped(ArcSessionObserver::StopReason::SHUTDOWN);
     return;
   }
 
   if (result != StartArcInstanceResult::SUCCESS) {
     LOG(ERROR) << "Failed to start ARC instance";
     OnStopped(result == StartArcInstanceResult::LOW_FREE_DISK_SPACE
-                  ? ArcBridgeService::StopReason::LOW_DISK_SPACE
-                  : ArcBridgeService::StopReason::GENERIC_BOOT_FAILURE);
+                  ? ArcSessionObserver::StopReason::LOW_DISK_SPACE
+                  : ArcSessionObserver::StopReason::GENERIC_BOOT_FAILURE);
     return;
   }
 
   VLOG(2) << "ARC instance is successfully started. Connecting Mojo...";
   state_ = State::CONNECTING_MOJO;
 
   // Prepare a pipe so that AcceptInstanceConnection can be interrupted on
   // Stop().
   base::ScopedFD cancel_fd;
   if (!CreatePipe(&cancel_fd, &accept_cancel_pipe_)) {
-    OnStopped(ArcBridgeService::StopReason::GENERIC_BOOT_FAILURE);
+    OnStopped(ArcSessionObserver::StopReason::GENERIC_BOOT_FAILURE);
     return;
   }
 
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_.get(), FROM_HERE,
       base::Bind(&ArcSessionImpl::ConnectMojo, base::Passed(&socket_fd),
                  base::Passed(&cancel_fd)),
       base::Bind(&ArcSessionImpl::OnMojoConnected, weak_factory_.GetWeakPtr()));
 }
 
@@ skipping 69 matching lines @@
 
   mojom::ArcBridgeInstancePtr instance;
   instance.Bind(mojo::InterfacePtrInfo<mojom::ArcBridgeInstance>(
       std::move(server_pipe), 0u));
   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();
+    observer.OnSessionReady();
 }
 
 void ArcSessionImpl::Stop() {
   DCHECK(thread_checker_.CalledOnValidThread());
   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);
+      OnStopped(ArcSessionObserver::StopReason::SHUTDOWN);
       return;
 
     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,
       // and stopping procedure will be run there.
       // On Chrome shutdown, it is not the case because the message loop is
       // already stopped here. Practically, it is not a problem because;
       // - On socket creating, it is ok to simply ignore such cases,
@@ skipping 36 matching lines @@
 
 void ArcSessionImpl::ArcInstanceStopped(bool clean) {
   DCHECK(thread_checker_.CalledOnValidThread());
   VLOG(1) << "Notified that ARC instance is stopped "
           << (clean ? "cleanly" : "uncleanly");
 
   // In case that crash happens during before the Mojo channel is connected,
   // unlock the BlockingPool thread.
   accept_cancel_pipe_.reset();
 
-  ArcBridgeService::StopReason reason;
+  ArcSessionObserver::StopReason reason;
   if (stop_requested_) {
     // If the ARC instance is stopped after its explicit request,
     // return SHUTDOWN.
-    reason = ArcBridgeService::StopReason::SHUTDOWN;
+    reason = ArcSessionObserver::StopReason::SHUTDOWN;
   } else if (clean) {
     // If the ARC instance is stopped, but it is not explicitly requested,
     // then this is triggered by some failure during the starting procedure.
     // Return GENERIC_BOOT_FAILURE for the case.
-    reason = ArcBridgeService::StopReason::GENERIC_BOOT_FAILURE;
+    reason = ArcSessionObserver::StopReason::GENERIC_BOOT_FAILURE;
   } else {
     // Otherwise, this is caused by CRASH occured inside of the ARC instance.
-    reason = ArcBridgeService::StopReason::CRASH;
+    reason = ArcSessionObserver::StopReason::CRASH;
   }
   OnStopped(reason);
 }
 
-void ArcSessionImpl::OnStopped(ArcBridgeService::StopReason reason) {
+void ArcSessionImpl::OnStopped(ArcSessionObserver::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;
   for (auto& observer : observer_list_)
-    observer.OnStopped(reason);
+    observer.OnSessionStopped(reason);
 }
 
 void ArcSessionImpl::OnShutdown() {
   DCHECK(thread_checker_.CalledOnValidThread());
   stop_requested_ = true;
   if (state_ == State::STOPPED)
     return;
 
   // Here, the message loop is already stopped, and the Chrome will be soon
   // shutdown. Thus, it is not necessary to take care about restarting case.
   // If ArcSession is waiting for mojo connection, cancels it. The BlockingPool
   // will be joined later.
   accept_cancel_pipe_.reset();
 
   // Stops the ARC instance to let it graceful shutdown.
   // Note that this may fail if ARC container is not actually running, but
   // ignore an error as described below.
   if (state_ == State::STARTING_INSTANCE ||
       state_ == State::CONNECTING_MOJO || state_ == State::RUNNING)
     StopArcInstance();
 
   // Directly set to the STOPPED stateby OnStopped(). Note that calling
   // StopArcInstance() may not work well. At least, because the UI thread is
   // already stopped here, ArcInstanceStopped() callback cannot be invoked.
-  OnStopped(ArcBridgeService::StopReason::SHUTDOWN);
+  OnStopped(ArcSessionObserver::StopReason::SHUTDOWN);
 }
 
 }  // namespace
 
 ArcSession::ArcSession() = default;
 ArcSession::~ArcSession() = default;
 
-void ArcSession::AddObserver(Observer* observer) {
+void ArcSession::AddObserver(ArcSessionObserver* observer) {
   observer_list_.AddObserver(observer);
 }
 
-void ArcSession::RemoveObserver(Observer* observer) {
+void ArcSession::RemoveObserver(ArcSessionObserver* 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>(arc_bridge_service,
                                           blocking_task_runner);
 }
 
 }  // namespace arc