arc-bridge: Restart ARC instance on crash

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/sequenced_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "chromeos/chromeos_switches.h"
 #include "components/arc/arc_bridge_service_impl.h"
 
 namespace arc {
 
 namespace {
 
 // Weak pointer.  This class is owned by ArcServiceManager.
 ArcBridgeService* g_arc_bridge_service = nullptr;
 
 }  // namespace
 
 ArcBridgeService::ArcBridgeService()
-    : available_(false), state_(State::STOPPED) {
+    : available_(false), state_(State::STOPPED), weak_factory_(this) {
   DCHECK(!g_arc_bridge_service);
   g_arc_bridge_service = this;
 }
 
 ArcBridgeService::~ArcBridgeService() {
   DCHECK(CalledOnValidThread());
   DCHECK(state() == State::STOPPING || state() == State::STOPPED);
   DCHECK(g_arc_bridge_service == this);
   g_arc_bridge_service = nullptr;
 }
@@ skipping 17 matching lines @@
 
 void ArcBridgeService::RemoveObserver(Observer* observer) {
   DCHECK(CalledOnValidThread());
   observer_list_.RemoveObserver(observer);
 }
 
 void ArcBridgeService::OnAppInstanceReady(AppInstancePtr app_ptr) {
   DCHECK(CalledOnValidThread());
   app_ptr_ = std::move(app_ptr);
   FOR_EACH_OBSERVER(Observer, observer_list(), OnAppInstanceReady());
+  app_ptr_.set_connection_error_handler(base::Bind(
+      &ArcBridgeService::OnAppChannelClosed, weak_factory_.GetWeakPtr()));
+}
+
+void ArcBridgeService::OnAppChannelClosed() {
+  DCHECK(CalledOnValidThread());
+  if (!app_ptr_)
+    return;
+
+  app_ptr_.reset();
+  FOR_EACH_OBSERVER(Observer, observer_list(), OnAppInstanceClosed());
 }
 
 void ArcBridgeService::OnInputInstanceReady(InputInstancePtr input_ptr) {
   DCHECK(CalledOnValidThread());
   input_ptr_ = std::move(input_ptr);
   FOR_EACH_OBSERVER(Observer, observer_list(), OnInputInstanceReady());
+  input_ptr_.set_connection_error_handler(base::Bind(
+      &ArcBridgeService::OnInputChannelClosed, weak_factory_.GetWeakPtr()));
+}
+
+void ArcBridgeService::OnInputChannelClosed() {
+  DCHECK(CalledOnValidThread());
+  if (!input_ptr_)
+    return;
+
+  input_ptr_.reset();
+  FOR_EACH_OBSERVER(Observer, observer_list(), OnInputInstanceClosed());
 }
 
 void ArcBridgeService::OnNotificationsInstanceReady(
     NotificationsInstancePtr notifications_ptr) {
   DCHECK(CalledOnValidThread());
   notifications_ptr_ = std::move(notifications_ptr);
   FOR_EACH_OBSERVER(Observer, observer_list(), OnNotificationsInstanceReady());
+  notifications_ptr_.set_connection_error_handler(
+      base::Bind(&ArcBridgeService::OnNotificationsChannelClosed,
+                 weak_factory_.GetWeakPtr()));
+}
+
+void ArcBridgeService::OnNotificationsChannelClosed() {
+  DCHECK(CalledOnValidThread());
+  if (!notifications_ptr_)
+    return;
+
+  notifications_ptr_.reset();
+  FOR_EACH_OBSERVER(Observer, observer_list(), OnNotificationsInstanceClosed());
 }
 
 void ArcBridgeService::OnPowerInstanceReady(PowerInstancePtr power_ptr) {
   DCHECK(CalledOnValidThread());
   power_ptr_ = std::move(power_ptr);
   FOR_EACH_OBSERVER(Observer, observer_list(), OnPowerInstanceReady());
+  power_ptr_.set_connection_error_handler(base::Bind(
+      &ArcBridgeService::OnPowerChannelClosed, weak_factory_.GetWeakPtr()));
+}
+
+void ArcBridgeService::OnPowerChannelClosed() {
+  DCHECK(CalledOnValidThread());
+  if (!power_ptr_)
+    return;
+
+  power_ptr_.reset();
+  FOR_EACH_OBSERVER(Observer, observer_list(), OnPowerInstanceClosed());
 }
 
 void ArcBridgeService::OnProcessInstanceReady(ProcessInstancePtr process_ptr) {
   DCHECK(CalledOnValidThread());
   process_ptr_ = std::move(process_ptr);
   FOR_EACH_OBSERVER(Observer, observer_list(), OnProcessInstanceReady());
+  process_ptr_.set_connection_error_handler(base::Bind(
+      &ArcBridgeService::OnProcessChannelClosed, weak_factory_.GetWeakPtr()));
+}
+
+void ArcBridgeService::OnProcessChannelClosed() {
+  DCHECK(CalledOnValidThread());
+  if (!process_ptr_)
+    return;
+
+  process_ptr_.reset();
+  FOR_EACH_OBSERVER(Observer, observer_list(), OnProcessInstanceClosed());
 }
 
 void ArcBridgeService::OnSettingsInstanceReady(
     SettingsInstancePtr settings_ptr) {
   DCHECK(CalledOnValidThread());
   settings_ptr_ = std::move(settings_ptr);
   FOR_EACH_OBSERVER(Observer, observer_list(), OnSettingsInstanceReady());
+  settings_ptr_.set_connection_error_handler(base::Bind(
+      &ArcBridgeService::OnSettingsChannelClosed, weak_factory_.GetWeakPtr()));
+}
+
+void ArcBridgeService::OnSettingsChannelClosed() {
+  DCHECK(CalledOnValidThread());
+  if (!settings_ptr_)
+    return;
+
+  settings_ptr_.reset();
+  FOR_EACH_OBSERVER(Observer, observer_list(), OnSettingsInstanceClosed());
 }
 
 void ArcBridgeService::SetState(State state) {
   DCHECK(CalledOnValidThread());
   // DCHECK on enum classes not supported.
   DCHECK(state_ != state);
   state_ = state;
   FOR_EACH_OBSERVER(Observer, observer_list(), OnStateChanged(state_));
 }
 
 void ArcBridgeService::SetAvailable(bool available) {
   DCHECK(CalledOnValidThread());
   DCHECK(available_ != available);
   available_ = available;
   FOR_EACH_OBSERVER(Observer, observer_list(), OnAvailableChanged(available_));
 }
 
 bool ArcBridgeService::CalledOnValidThread() {
   return thread_checker_.CalledOnValidThread();
 }
 
+void ArcBridgeService::CloseAllChannels() {

[hidehiko, 2015/12/29 13:27:12]

This method looks not actually close the channels?

[Luis Héctor Chávez, 2015/12/29 17:17:36]

It does, but let me add a comment to make it more clear.

[hidehiko, 2016/01/05 08:17:13]

Oh, I was confused by the name.
So, let's rename the methods, e.g. OnAppChannelClosed -> CloseAppChannel, etc.
Actually, even on error, there seem cases that the channel is still kept open,
so passing the CloseAppChannel as a error-handling callback should make sense,
IMHO. WDYT?

[Luis Héctor Chávez, 2016/01/05 18:59:21]

When there is an error, Mojo closes the channel first, and then calls the
callback (if any). There should be no cases where there is an error (on an
interface) and the channel (for that interface) is still kept open.

But I'm not opposed to renaming, so Done.

+  OnAppChannelClosed();
+  OnInputChannelClosed();
+  OnNotificationsChannelClosed();
+  OnPowerChannelClosed();
+  OnProcessChannelClosed();
+  OnSettingsChannelClosed();
+}
+
 }  // namespace arc