Turn ArcSupportHost from Observer model to Delegate

chrome/browser/chromeos/arc/arc_support_host.cc

 // Copyright 2016 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 "chrome/browser/chromeos/arc/arc_support_host.h"
 
 #include <string>
 #include <utility>
 
 #include "ash/system/devicetype_utils.h"
 #include "base/bind.h"
 #include "base/i18n/timezone.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/memory/ptr_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_utils.h"
 #include "chrome/browser/ui/ash/multi_user/multi_user_util.h"
 #include "chrome/browser/ui/extensions/app_launch_params.h"
 #include "chrome/browser/ui/extensions/application_launch.h"
+#include "chrome/common/pref_names.h"
 #include "chrome/grit/generated_resources.h"
+#include "components/prefs/pref_service.h"
 #include "components/user_manager/known_user.h"
 #include "extensions/browser/extension_registry.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/webui/web_ui_util.h"
 #include "ui/display/screen.h"
 
 namespace {
 constexpr char kAction[] = "action";
 constexpr char kArcManaged[] = "arcManaged";
 constexpr char kData[] = "data";
@@ skipping 118 matching lines @@
 // static
 const char ArcSupportHost::kStorageId[] = "arc_support";
 
 ArcSupportHost::ArcSupportHost(Profile* profile)
     : profile_(profile),
       request_open_app_callback_(base::Bind(&RequestOpenApp)) {
   DCHECK(profile_);
 }
 
 ArcSupportHost::~ArcSupportHost() {
+  // Delegates should have been reset to nullptr at this point.
+  DCHECK(!auth_delegate_);
+  DCHECK(!tos_delegate_);
+  DCHECK(!error_delegate_);
+
   if (message_host_)
     DisconnectMessageHost();
 }
 
 void ArcSupportHost::AddObserver(Observer* observer) {
   observer_list_.AddObserver(observer);
 }
 
 void ArcSupportHost::RemoveObserver(Observer* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
 bool ArcSupportHost::HasObserver(Observer* observer) {
   return observer_list_.HasObserver(observer);
 }
 
+void ArcSupportHost::SetAuthDelegate(AuthDelegate* delegate) {
+  // Since AuthDelegate and TermsOfServiceDelegate should not have overlapping
+  // life cycle, both delegates can't be non-null at the same time.
+  DCHECK(!(delegate && tos_delegate_));
+  auth_delegate_ = delegate;
+}
+
+void ArcSupportHost::SetTermsOfServiceDelegate(
+    TermsOfServiceDelegate* delegate) {
+  // Since AuthDelegate and TermsOfServiceDelegate should not have overlapping
+  // life cycle, both delegates can't be non-null at the same time.
+  DCHECK(!(delegate && auth_delegate_));
+  tos_delegate_ = delegate;
+}
+
+void ArcSupportHost::SetErrorDelegate(ErrorDelegate* delegate) {
+  error_delegate_ = delegate;
+}
+
 void ArcSupportHost::SetArcManaged(bool is_arc_managed) {
   DCHECK(!message_host_);
   is_arc_managed_ = is_arc_managed;
 }
 
 void ArcSupportHost::Close() {
   ui_page_ = UIPage::NO_PAGE;
   if (!message_host_) {
     VLOG(2) << "ArcSupportHost::Close() is called "
             << "but message_host_ is not available.";
@@ skipping 320 matching lines @@
 }
 
 void ArcSupportHost::OnMessage(const base::DictionaryValue& message) {
   std::string event;
   if (!message.GetString(kEvent, &event)) {
     NOTREACHED();
     return;
   }
 
   if (event == kEventOnWindowClosed) {
-    for (auto& observer : observer_list_)
-      observer.OnWindowClosed();
+    // If ToS negotiation is ongoing, call the specific function.
+    if (tos_delegate_) {
+      tos_delegate_->OnTermsRejected();
+    } else {
+      DCHECK(error_delegate_);

[khmel, 2017/05/26 19:43:46]

What if OptIn is closed during the progress.
In this case we should not stop ARC.
ARC is stopped only in case OptIn UI closed on Start or Error page.
Is this true with new code?

[victorhsieh0, 2017/05/27 00:07:07]

Done.  Renamed the function as discussed offline.

+      error_delegate_->OnOptInAborted();
+    }
   } else if (event == kEventOnAuthSucceeded) {
+    DCHECK(auth_delegate_);
     std::string code;
     if (message.GetString(kCode, &code)) {
-      for (auto& observer : observer_list_)
-        observer.OnAuthSucceeded(code);
+      auth_delegate_->OnAuthSucceeded(code);
     } else {
       NOTREACHED();
     }
   } else if (event == kEventOnAuthFailed) {
-    for (auto& observer : observer_list_)
-      observer.OnAuthFailed();
+    DCHECK(auth_delegate_);
+    auth_delegate_->OnAuthFailed();
   } else if (event == kEventOnAgreed) {
+    DCHECK(tos_delegate_);
     bool is_metrics_enabled;
     bool is_backup_restore_enabled;
     bool is_location_service_enabled;
     if (message.GetBoolean(kIsMetricsEnabled, &is_metrics_enabled) &&
         message.GetBoolean(kIsBackupRestoreEnabled,
                            &is_backup_restore_enabled) &&
         message.GetBoolean(kIsLocationServiceEnabled,
                            &is_location_service_enabled)) {
-      for (auto& observer : observer_list_) {
-        observer.OnTermsAgreed(is_metrics_enabled, is_backup_restore_enabled,
-                               is_location_service_enabled);
-      }
+      tos_delegate_->OnTermsAgreed(is_metrics_enabled,
+                                   is_backup_restore_enabled,
+                                   is_location_service_enabled);
     } else {
       NOTREACHED();
     }
   } else if (event == kEventOnRetryClicked) {
-    for (auto& observer : observer_list_)
-      observer.OnRetryClicked();
+    // If ToS negotiation or manual authentication is ongoing, call the
+    // corresponding delegate.  Otherwise, call the general retry function.
+    if (tos_delegate_) {
+      tos_delegate_->OnTermsRetryClicked();
+    } else if (auth_delegate_) {
+      auth_delegate_->OnAuthRetryClicked();
+    } else {
+      DCHECK(error_delegate_);
+      error_delegate_->OnRetryClicked();
+    }
   } else if (event == kEventOnSendFeedbackClicked) {
-    for (auto& observer : observer_list_)
-      observer.OnSendFeedbackClicked();
+    DCHECK(error_delegate_);
+    error_delegate_->OnSendFeedbackClicked();
   } else {
     LOG(ERROR) << "Unknown message: " << event;
     NOTREACHED();
   }
 }