Set timeout in sync setup

chrome/browser/ui/webui/sync_setup_handler.cc

 // Copyright (c) 2012 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/sync_setup_handler.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
@@ skipping 267 matching lines @@
   localized_strings->SetString("createAccountLinkHTML",
       GetStringFUTF16(IDS_SYNC_CREATE_ACCOUNT_PREFIX, create_account));
 
   string16 sync_benefits_url(
       UTF8ToUTF16(google_util::StringAppendGoogleLocaleParam(
           chrome::kSyncLearnMoreURL)));
   localized_strings->SetString("promoLearnMoreURL", sync_benefits_url);
 
   static OptionsStringResource resources[] = {
     { "syncSetupConfigureTitle", IDS_SYNC_SETUP_CONFIGURE_TITLE },
+    { "syncSetupTimeoutTitle", IDS_SYNC_SETUP_TIME_OUT_TITLE },
+    { "syncSetupTimeoutContent", IDS_SYNC_SETUP_TIME_OUT_CONTENT },
     { "cannotBeBlank", IDS_SYNC_CANNOT_BE_BLANK },
     { "emailLabel", IDS_SYNC_LOGIN_EMAIL_NEW_LINE },
     { "passwordLabel", IDS_SYNC_LOGIN_PASSWORD_NEW_LINE },
     { "invalidCredentials", IDS_SYNC_INVALID_USER_CREDENTIALS },
     { "signin", IDS_SYNC_SIGNIN },
     { "couldNotConnect", IDS_SYNC_LOGIN_COULD_NOT_CONNECT },
     { "unrecoverableError", IDS_SYNC_UNRECOVERABLE_ERROR },
     { "errorLearnMore", IDS_LEARN_MORE },
     { "unrecoverableErrorHelpURL", IDS_SYNC_UNRECOVERABLE_ERROR_HELP_URL },
     { "cannotAccessAccount", IDS_SYNC_CANNOT_ACCESS_ACCOUNT },
@@ skipping 182 matching lines @@
       base::Bind(&SyncSetupHandler::HandleShowSetupUI,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "SyncSetupShowSetupUIWithoutLogin",
       base::Bind(&SyncSetupHandler::HandleShowSetupUIWithoutLogin,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "SyncSetupDoSignOutOnAuthError",
       base::Bind(&SyncSetupHandler::HandleDoSignOutOnAuthError,
                  base::Unretained(this)));
+  web_ui()->RegisterMessageCallback("CloseTimeout",
+      base::Bind(&SyncSetupHandler::HandleCloseTimeout,
+                 base::Unretained(this)));
   web_ui()->RegisterMessageCallback("SyncSetupStopSyncing",
       base::Bind(&SyncSetupHandler::HandleStopSyncing,
                  base::Unretained(this)));
 }
 
 SigninManager* SyncSetupHandler::GetSignin() const {
   return SigninManagerFactory::GetForProfile(GetProfile());
 }
 
 void SyncSetupHandler::DisplayGaiaLogin(bool fatal_error) {
@@ skipping 84 matching lines @@
 
   return true;
 }
 
 // TODO(kochi): Handle error conditions (timeout, other failures).
 // http://crbug.com/128692
 void SyncSetupHandler::DisplaySpinner() {
   configuring_sync_ = true;
   StringValue page("spinner");
   DictionaryValue args;
+
+  const int kTimeoutSec = 30;
+  DCHECK(!backend_start_timer_.get());
+  backend_start_timer_.reset(new base::OneShotTimer<SyncSetupHandler>());
+  backend_start_timer_->Start(FROM_HERE,
+                              base::TimeDelta::FromSeconds(kTimeoutSec),
+                              this, &SyncSetupHandler::DisplayTimeout);
+
+  web_ui()->CallJavascriptFunction(
+      "SyncSetupOverlay.showSyncSetupPage", page, args);
+}
+
+// TODO(kochi): Handle error conditions other than timeout.
+// http://crbug.com/128692
+void SyncSetupHandler::DisplayTimeout() {
+  // Stop a timer to handle timeout in waiting for checking network connection.
+  backend_start_timer_.reset();
+
+  // Do not listen to signin events.
+  signin_tracker_.reset();
+
+  StringValue page("timeout");
+  DictionaryValue args;
   web_ui()->CallJavascriptFunction(
       "SyncSetupOverlay.showSyncSetupPage", page, args);
 }
 
 void SyncSetupHandler::RecordSignin() {
   // By default, do nothing - subclasses can override.
 }
 
 void SyncSetupHandler::DisplayGaiaSuccessAndClose() {
   RecordSignin();
@@ skipping 106 matching lines @@
 }
 
 void SyncSetupHandler::GaiaCredentialsValid() {
   DCHECK(IsActiveLogin());
 
   // Gaia credentials are valid - update the UI.
   DisplayGaiaSuccessAndSettingUp();
 }
 
 void SyncSetupHandler::SigninFailed(const GoogleServiceAuthError& error) {
+  // Stop a timer to handle timeout in waiting for checking network connection.
+  backend_start_timer_.reset();
+
   last_signin_error_ = error;
   // Got a failed signin - this is either just a typical auth error, or a
   // sync error (treat sync errors as "fatal errors" - i.e. non-auth errors).
   // On ChromeOS, this condition can happen when auth token is invalid and
   // cannot start sync backend.
   if (retry_on_signin_failure_) {
     DisplayGaiaLogin(GetSyncService()->HasUnrecoverableError());
   } else {
     // TODO(peria): Show error dialog for prompting sign in and out on
     // Chrome OS. http://crbug.com/128692
     CloseOverlay();
   }
 }
 
 Profile* SyncSetupHandler::GetProfile() const {
   return Profile::FromWebUI(web_ui());
 }
 
 ProfileSyncService* SyncSetupHandler::GetSyncService() const {
   return ProfileSyncServiceFactory::GetForProfile(GetProfile());
 }
 
 void SyncSetupHandler::SigninSuccess() {
   DCHECK(GetSyncService()->sync_initialized());
+  // Stop a timer to handle timeout in waiting for checking network connection.
+  backend_start_timer_.reset();
+
   // If we have signed in while sync is already setup, it must be due to some
   // kind of re-authentication flow. In that case, just close the signin dialog
   // rather than forcing the user to go through sync configuration.
   if (GetSyncService()->HasSyncSetupCompleted())
     DisplayGaiaSuccessAndClose();
   else
     DisplayConfigureSync(false, false);
 }
 
 void SyncSetupHandler::HandleConfigure(const ListValue* args) {
@@ skipping 139 matching lines @@
 void SyncSetupHandler::HandleStopSyncing(const ListValue* args) {
   ProfileSyncService* service = GetSyncService();
   DCHECK(service);
 
   if (ProfileSyncService::IsSyncEnabled()) {
     service->DisableForUser();
     ProfileSyncService::SyncEvent(ProfileSyncService::STOP_FROM_OPTIONS);
   }
 }
 
+void SyncSetupHandler::HandleCloseTimeout(const ListValue* args) {
+  CloseSyncSetup();
+}
+
 void SyncSetupHandler::CloseSyncSetup() {
   // TODO(atwilson): Move UMA tracking of signin events out of sync module.
   ProfileSyncService* sync_service = GetSyncService();
   if (IsActiveLogin()) {
     if (!sync_service->HasSyncSetupCompleted()) {
       if (signin_tracker_.get()) {
         ProfileSyncService::SyncEvent(
             ProfileSyncService::CANCEL_DURING_SIGNON);
       } else if (configuring_sync_) {
         ProfileSyncService::SyncEvent(
@@ skipping 23 matching lines @@
   }
 
   // Reset the attempted email address and error, otherwise the sync setup
   // overlay in the settings page will stay in whatever error state it was last
   // when it is reopened.
   last_attempted_user_email_.clear();
   last_signin_error_ = GoogleServiceAuthError::None();
 
   configuring_sync_ = false;
   signin_tracker_.reset();
+
+  // Stop a timer to handle timeout in waiting for checking network connection.
+  backend_start_timer_.reset();
 }
 
 void SyncSetupHandler::OpenSyncSetup(bool force_login) {
   if (!PrepareSyncSetup())
     return;
 
   ProfileSyncService* service = GetSyncService();
 
   // There are several different UI flows that can bring the user here:
   // 1) Signin promo (passes force_login=true)
@@ skipping 49 matching lines @@
     return false;
   service->current_login_ui()->FocusUI();
   return true;
 }
 
 LoginUIService* SyncSetupHandler::GetLoginUIService() const {
   return LoginUIServiceFactory::GetForProfile(GetProfile());
 }
 
 void SyncSetupHandler::CloseOverlay() {
+  // Stop a timer to handle timeout in waiting for sync setup.
+  backend_start_timer_.reset();
+
   CloseSyncSetup();
   web_ui()->CallJavascriptFunction("OptionsPage.closeOverlay");
 }
 
 bool SyncSetupHandler::IsLoginAuthDataValid(const std::string& username,
                                             string16* error_message) {
   if (username.empty())
     return true;
 
   // Can be null during some unit tests.
@@ skipping 19 matching lines @@
     if (i != current_profile_index && AreUserNamesEqual(
         cache.GetUserNameOfProfileAtIndex(i), username_utf16)) {
       *error_message = l10n_util::GetStringUTF16(
           IDS_SYNC_USER_NAME_IN_USE_ERROR);
       return false;
     }
   }
 
   return true;
 }