Migrate ArcBridgeService::Observer and ArcSession::Observer.

components/arc/arc_bridge_service.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_service.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/feature_list.h"
 #include "base/sequenced_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chromeos/chromeos_switches.h"
 
 namespace arc {
 
 namespace {
 
 const base::Feature kArcEnabledFeature{"EnableARC",
                                        base::FEATURE_DISABLED_BY_DEFAULT};
 
 }  // namespace
 
 ArcBridgeService::ArcBridgeService()
     : state_(State::STOPPED),
-      stop_reason_(StopReason::SHUTDOWN),
+      stop_reason_(ArcSessionObserver::StopReason::SHUTDOWN),
       weak_factory_(this) {}
 
 ArcBridgeService::~ArcBridgeService() {
   DCHECK(CalledOnValidThread());
   DCHECK(state() == State::STOPPING || state() == State::STOPPED);
 }
 
 // static
 bool ArcBridgeService::GetEnabled(const base::CommandLine* command_line) {
   return command_line->HasSwitch(chromeos::switches::kEnableArc) ||
          (command_line->HasSwitch(chromeos::switches::kArcAvailable) &&
           base::FeatureList::IsEnabled(kArcEnabledFeature));
 }
 
 // static
 bool ArcBridgeService::GetAvailable(const base::CommandLine* command_line) {
   return command_line->HasSwitch(chromeos::switches::kArcAvailable);
 }
 
-void ArcBridgeService::AddObserver(Observer* observer) {
+void ArcBridgeService::AddObserver(ArcSessionObserver* observer) {
   DCHECK(CalledOnValidThread());
   observer_list_.AddObserver(observer);
 }
 
-void ArcBridgeService::RemoveObserver(Observer* observer) {
+void ArcBridgeService::RemoveObserver(ArcSessionObserver* observer) {
   DCHECK(CalledOnValidThread());
   observer_list_.RemoveObserver(observer);
 }
 
 void ArcBridgeService::SetState(State state) {
   DCHECK(CalledOnValidThread());
   DCHECK_NE(state_, state);
   state_ = state;
   VLOG(2) << "State: " << static_cast<uint32_t>(state_);
   if (state_ == State::READY) {
     for (auto& observer : observer_list())
-      observer.OnBridgeReady();
+      observer.OnReady();
   } else if (state == State::STOPPED) {
     for (auto& observer : observer_list())
-      observer.OnBridgeStopped(stop_reason_);
+      observer.OnStopped(stop_reason_);
   }
 }
 
-void ArcBridgeService::SetStopReason(StopReason stop_reason) {
+void ArcBridgeService::SetStopReason(
+    ArcSessionObserver::StopReason stop_reason) {
   DCHECK(CalledOnValidThread());
   stop_reason_ = stop_reason;
 }
 
 bool ArcBridgeService::CalledOnValidThread() {
   return thread_checker_.CalledOnValidThread();
 }
 
-std::ostream& operator<<(
-    std::ostream& os, ArcBridgeService::StopReason reason) {
-  switch (reason) {
-#define CASE_IMPL(val) \
-    case ArcBridgeService::StopReason::val: \
-      return os << #val
-
-    CASE_IMPL(SHUTDOWN);
-    CASE_IMPL(GENERIC_BOOT_FAILURE);
-    CASE_IMPL(LOW_DISK_SPACE);
-    CASE_IMPL(CRASH);
-#undef CASE_IMPL
-  }
-
-  // In case of unexpected value, output the int value.
-  return os << "StopReason(" << static_cast<int>(reason) << ")";
-}
-
 }  // namespace arc