arc: Notify ARC instance failures via callbacks.

components/arc/arc_bridge_service.h

 // 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.
 
 #ifndef COMPONENTS_ARC_ARC_BRIDGE_SERVICE_H_
 #define COMPONENTS_ARC_ARC_BRIDGE_SERVICE_H_
 
 #include <string>
 #include <vector>
 
 #include "base/files/scoped_file.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/observer_list.h"
 #include "base/values.h"
 #include "components/arc/common/arc_bridge.mojom.h"
 #include "components/arc/instance_holder.h"
 
 namespace base {
 class CommandLine;
 }  // namespace base
 
 namespace arc {
 
-class ArcBridgeBootstrap;
 class ArcBridgeTest;
 
 // The Chrome-side service that handles ARC instances and ARC bridge creation.
 // This service handles the lifetime of ARC instances and sets up the
 // communication channel (the ARC bridge) used to send and receive messages.
 class ArcBridgeService : public mojom::ArcBridgeHost {
  public:
+  // Describes the reason the bridge is stopped.
+  enum class StopReason {
+    // ARC instance has been gracefully shut down.
+    SHUTDOWN,
+
+    // Errors occurred during the ARC instance boot. This includes any failures
+    // before the instance is actually attempted to be started, and also
+    // failures on bootstrapping IPC channels with Android.
+    GENERIC_BOOT_FAILURE,
+
+    // ARC instance has crashed.
+    CRASH,
+  };
+
   // Notifies life cycle events of ArcBridgeService.
   class Observer {
    public:
     // Called whenever the state of the bridge has changed.
     virtual void OnBridgeReady() {}
-    virtual void OnBridgeStopped() {}
+    virtual void OnBridgeStopped(StopReason reason) {}
 
     // Called whenever ARC's availability has changed for this system.
     virtual void OnAvailableChanged(bool available) {}
 
    protected:
     virtual ~Observer() {}
   };
 
   ~ArcBridgeService() override;
 
@@ skipping 139 matching lines @@
 
   // Gets the current state of the bridge service.
   State state() const { return state_; }
 
   // Changes the current state and notifies all observers.
   void SetState(State state);
 
   // Changes the current availability and notifies all observers.
   void SetAvailable(bool availability);
 
+  // Sets the reason the bridge is stopped. This function must be always called
+  // before SetState(State::STOPPED) to report a correct reason with
+  // Observer::OnBridgeStopped().
+  void SetStopReason(StopReason stop_reason);
+
   base::ObserverList<Observer>& observer_list() { return observer_list_; }
 
   bool CalledOnValidThread();
 
   // Closes all Mojo channels.
   void CloseAllChannels();
 
  private:
   friend class ArcBridgeTest;
   FRIEND_TEST_ALL_PREFIXES(ArcBridgeTest, Basic);
   FRIEND_TEST_ALL_PREFIXES(ArcBridgeTest, Prerequisites);
   FRIEND_TEST_ALL_PREFIXES(ArcBridgeTest, ShutdownMidStartup);
   FRIEND_TEST_ALL_PREFIXES(ArcBridgeTest, Restart);
+  FRIEND_TEST_ALL_PREFIXES(ArcBridgeTest, OnBridgeStopped);
 
   // Instance holders.
   InstanceHolder<mojom::AppInstance> app_;
   InstanceHolder<mojom::AudioInstance> audio_;
   InstanceHolder<mojom::AuthInstance> auth_;
   InstanceHolder<mojom::BluetoothInstance> bluetooth_;
   InstanceHolder<mojom::ClipboardInstance> clipboard_;
   InstanceHolder<mojom::CrashCollectorInstance> crash_collector_;
   InstanceHolder<mojom::FileSystemInstance> file_system_;
   InstanceHolder<mojom::ImeInstance> ime_;
@@ skipping 12 matching lines @@
   base::ObserverList<Observer> observer_list_;
 
   base::ThreadChecker thread_checker_;
 
   // If the ARC instance service is available.
   bool available_;
 
   // The current state of the bridge.
   ArcBridgeService::State state_;
 
+  // The reason the bridge is stopped.
+  StopReason stop_reason_;
+
   // WeakPtrFactory to use callbacks.
   base::WeakPtrFactory<ArcBridgeService> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ArcBridgeService);
 };
 
 }  // namespace arc
 
 #endif  // COMPONENTS_ARC_ARC_BRIDGE_SERVICE_H_