Fixed Gaia reloading.

chrome/browser/ui/webui/chromeos/login/signin_screen_handler.cc

 // Copyright (c) 2013 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/ui/webui/chromeos/login/signin_screen_handler.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 83 matching lines @@
 // Type of the login screen UI that is currently presented to user.
 const char kSourceGaiaSignin[] = "gaia-signin";
 const char kSourceAccountPicker[] = "account-picker";
 
 static bool Contains(const std::vector<std::string>& container,
                      const std::string& value) {
   return std::find(container.begin(), container.end(), value) !=
          container.end();
 }
 
+class CallOnReturn {
+ public:
+  explicit CallOnReturn(const base::Closure& callback)
+      : callback_(callback), call_scheduled_(false) {}
+
+  ~CallOnReturn() {
+    if (call_scheduled_ && !callback_.is_null())
+      callback_.Run();
+  }
+
+  void ScheduleCall() { call_scheduled_ = true; }
+
+ private:
+  base::Closure callback_;
+  bool call_scheduled_;
+
+  DISALLOW_COPY_AND_ASSIGN(CallOnReturn);
+};
+
 }  // namespace
 
 namespace chromeos {
 
 namespace {
 
 bool IsOnline(NetworkStateInformer::State state,
               ErrorScreenActor::ErrorReason reason) {
   return state == NetworkStateInformer::ONLINE &&
       reason != ErrorScreenActor::ERROR_REASON_PORTAL_DETECTED &&
@@ skipping 421 matching lines @@
       (reason == ErrorScreenActor::ERROR_REASON_LOADING_TIMEOUT);
   const bool is_gaia_error =
       FrameError() != net::OK && FrameError() != net::ERR_NETWORK_CHANGED;
   const bool is_gaia_signin = IsGaiaVisible() || IsGaiaHiddenByError();
   const bool error_screen_should_overlay =
       !offline_login_active_ && IsGaiaVisible();
   const bool from_not_online_to_online_transition =
       is_online && last_network_state_ != NetworkStateInformer::ONLINE;
   last_network_state_ = state;
 
+  CallOnReturn reload_gaia(base::Bind(
+      &SigninScreenHandler::ReloadGaia, weak_factory_.GetWeakPtr(), true));
+
   if (is_online || !is_behind_captive_portal)
     error_screen_actor_->HideCaptivePortal();
 
   // Hide offline message (if needed) and return if current screen is
   // not a Gaia frame.
   if (!is_gaia_signin) {
     if (!IsSigninScreenHiddenByError())
       HideOfflineMessage(state, reason);
     return;
   }
 
   // Reload frame if network state is changed from {!ONLINE} -> ONLINE state.
   if (reason == ErrorScreenActor::ERROR_REASON_NETWORK_STATE_CHANGED &&
       from_not_online_to_online_transition) {
     // Schedules a immediate retry.
-    LOG(WARNING) << "Retry page load since network has been changed.";
-    ReloadGaiaScreen();
+    LOG(WARNING) << "Retry frame load since network has been changed.";
+    reload_gaia.ScheduleCall();
   }
 
   if (reason == ErrorScreenActor::ERROR_REASON_PROXY_CONFIG_CHANGED &&
       error_screen_should_overlay) {
     // Schedules a immediate retry.
-    LOG(WARNING) << "Retry page load since proxy settings has been changed.";
-    ReloadGaiaScreen();
+    LOG(WARNING) << "Retry frameload since proxy settings has been changed.";
+    reload_gaia.ScheduleCall();
   }
 
   if (reason == ErrorScreenActor::ERROR_REASON_FRAME_ERROR &&
       !IsProxyError(state, reason, FrameError())) {
-    LOG(WARNING) << "Retry page load due to reason: "
+    LOG(WARNING) << "Retry frame load due to reason: "
                  << ErrorScreenActor::ErrorReasonString(reason);
-    ReloadGaiaScreen();
+    reload_gaia.ScheduleCall();
+  }
+
+  if (is_gaia_loading_timeout) {
+    LOG(WARNING) << "Retry frame load due to loading timeout.";
+    reload_gaia.ScheduleCall();
   }
 
   if ((!is_online || is_gaia_loading_timeout || is_gaia_error) &&
       !offline_login_active_) {
     SetupAndShowOfflineMessage(state, reason);
   } else {
     HideOfflineMessage(state, reason);
   }
 }
 
@@ skipping 52 matching lines @@
 void SigninScreenHandler::HideOfflineMessage(
     NetworkStateInformer::State state,
     ErrorScreenActor::ErrorReason reason) {
   if (!IsSigninScreenHiddenByError())
     return;
 
   error_screen_actor_->Hide();
 
   // Forces a reload for Gaia screen on hiding error message.
   if (IsGaiaVisible() || IsGaiaHiddenByError())
-    ReloadGaiaScreen();
+    ReloadGaia(false);

[Nikita (slow), 2014/07/23 13:34:16]

Comment says "Forces a reload for GAIA".
Considering IsGaiaHiddenByError() condition it seems that force_reload should be
true in this case.

[ygorshenin1, 2014/07/23 13:38:48]

Not sure, because we'll try to reload already reloading Gaia.

On 2014/07/23 13:34:16, Nikita Kostylev wrote:

[Nikita (slow), 2014/07/23 13:55:41]

As far as I understand in case of IsGaiaHiddenByError()
gaia loading might be stopped. If we don't force_reload it here what if it never
reloads again i.e. what guarantees that reload would actually finish.

[ygorshenin1, 2014/07/23 13:59:12]

ReloadGaia(true) means "reload gaia in any case, even if it's already loading".
ReloadGaia(false) means "reload gaia if it's not loading right now".
So call to ReloadGaia() in any case establishes that gaia is reloading.

On 2014/07/23 13:55:41, Nikita Kostylev wrote:

 }
 
-void SigninScreenHandler::ReloadGaiaScreen() {
-  gaia_screen_handler_->ReloadGaia();
+void SigninScreenHandler::ReloadGaia(bool force_reload) {
+  gaia_screen_handler_->ReloadGaia(force_reload);
 }
 
 void SigninScreenHandler::Initialize() {
   // If delegate_ is NULL here (e.g. WebUIScreenLocker has been destroyed),
   // don't do anything, just return.
   if (!delegate_)
     return;
 
   if (show_on_init_) {
     show_on_init_ = false;
@@ skipping 162 matching lines @@
                                   const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_AUTH_NEEDED: {
       has_pending_auth_ui_ = true;
       break;
     }
     case chrome::NOTIFICATION_AUTH_SUPPLIED:
       has_pending_auth_ui_ = false;
       // Reload auth extension as proxy credentials are supplied.
       if (!IsSigninScreenHiddenByError() && ui_state_ == UI_STATE_GAIA_SIGNIN)
-        ReloadGaiaScreen();
+        ReloadGaia(true);
       update_state_closure_.Cancel();
       break;
     case chrome::NOTIFICATION_AUTH_CANCELLED: {
       // Don't reload auth extension if proxy auth dialog was cancelled.
       has_pending_auth_ui_ = false;
       update_state_closure_.Cancel();
       break;
     }
     default:
       NOTREACHED() << "Unexpected notification " << type;
@@ skipping 532 matching lines @@
   return gaia_screen_handler_->frame_error();
 }
 
 void SigninScreenHandler::OnCapsLockChanged(bool enabled) {
   caps_lock_enabled_ = enabled;
   if (page_is_ready())
     CallJS("login.AccountPickerScreen.setCapsLockState", caps_lock_enabled_);
 }
 
 }  // namespace chromeos