Fixed sync re-activation when the device comes online after offline login.

chrome/browser/chromeos/login/login_utils.cc

 // Copyright (c) 2011 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/login/login_utils.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
@@ skipping 174 matching lines @@
                                      oauth1_secret_);
     }
   }
 
   // GaiaOAuthConsumer implementation:
   virtual void OnOAuthLoginSuccess(const std::string& sid,
                                    const std::string& lsid,
                                    const std::string& auth) OVERRIDE {
     GaiaAuthConsumer::ClientLoginResult credentials(sid,
       lsid, auth, std::string());
+    UserManager::Get()->set_offline_login(false);
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                             new StartSyncOnUIThreadTask(credentials));
   }
+
   virtual void OnOAuthLoginFailure(
       const GoogleServiceAuthError& error) OVERRIDE {
     LOG(WARNING) << "Failed to verify OAuth1 access tokens,"
                  << " error.state=" << error.state();
 
     // Mark this account's OAuth token state as invalid if the failure is not
     // caused by network error.
     if (error.state() != GoogleServiceAuthError::CONNECTION_FAILED) {
       UserManager::Get()->SaveUserOAuthStatus(username_,
             UserManager::OAUTH_TOKEN_STATUS_INVALID);
+    } else {
+      UserManager::Get()->set_offline_login(true);
     }
   }
 
  private:
   GaiaOAuthFetcher oauth_fetcher_;
   std::string oauth1_token_;
   std::string oauth1_secret_;
   std::string username_;
 
   DISALLOW_COPY_AND_ASSIGN(OAuthLoginVerifier);
@@ skipping 42 matching lines @@
   GaiaOAuthFetcher oauth_fetcher_;
   std::string oauth1_token_;
   std::string oauth1_secret_;
 
   DISALLOW_COPY_AND_ASSIGN(PolicyOAuthFetcher);
 };
 
 
 class LoginUtilsImpl : public LoginUtils,
                        public ProfileManagerObserver,
-                       public GaiaOAuthConsumer {
+                       public GaiaOAuthConsumer,
+                       public net::NetworkChangeNotifier::OnlineStateObserver {
  public:
   LoginUtilsImpl()
       : background_view_(NULL),
         pending_requests_(false),
         using_oauth_(false),
         has_cookies_(false),
         delegate_(NULL) {
+    net::NetworkChangeNotifier::AddOnlineStateObserver(this);
+  }
+
+  virtual ~LoginUtilsImpl() {
+    net::NetworkChangeNotifier::RemoveOnlineStateObserver(this);
   }
 
   virtual void PrepareProfile(
       const std::string& username,
       const std::string& password,
       const GaiaAuthConsumer::ClientLoginResult& credentials,
       bool pending_requests,
       bool using_oauth,
       bool has_cookies,
       LoginUtils::Delegate* delegate) OVERRIDE;
@@ skipping 53 matching lines @@
 
   // GaiaOAuthConsumer overrides.
   virtual void OnGetOAuthTokenSuccess(const std::string& oauth_token) OVERRIDE;
   virtual void OnGetOAuthTokenFailure(
     const GoogleServiceAuthError& error) OVERRIDE;
   virtual void OnOAuthGetAccessTokenSuccess(const std::string& token,
                                             const std::string& secret) OVERRIDE;
   virtual void OnOAuthGetAccessTokenFailure(
       const GoogleServiceAuthError& error) OVERRIDE;
 
+  // net::NetworkChangeNotifier::OnlineStateObserver overrides.
+  virtual void OnOnlineStateChanged(bool online) OVERRIDE;
+
  protected:
   virtual std::string GetOffTheRecordCommandLine(
       const GURL& start_url,
       const CommandLine& base_command_line,
       CommandLine *command_line);
 
  private:
   // Reads OAuth1 token from user profile's prefs.
   bool ReadOAuth1AccessToken(Profile* user_profile,
                              std::string* token,
@@ skipping 565 matching lines @@
       UserManager::OAUTH_TOKEN_STATUS_VALID) {
     return false;
   }
 
   PrefService* pref_service = user_profile->GetPrefs();
   std::string encoded_token = pref_service->GetString(prefs::kOAuth1Token);
   std::string encoded_secret = pref_service->GetString(prefs::kOAuth1Secret);
   if (!encoded_token.length() || !encoded_secret.length())
     return false;
 
+  DCHECK(authenticator_.get());
   std::string decoded_token = authenticator_->DecryptToken(encoded_token);
   std::string decoded_secret = authenticator_->DecryptToken(encoded_secret);
   if (!decoded_token.length() || !decoded_secret.length()) {
     // TODO(zelidrag): Remove legacy encryption support in R16.
     // Check if tokens were encoded with the legacy encryption instead.
     decoded_token = authenticator_->DecryptLegacyToken(encoded_token);
     decoded_secret = authenticator_->DecryptLegacyToken(encoded_secret);
     if (!decoded_token.length() || !decoded_secret.length())
       return false;
 
@@ skipping 64 matching lines @@
   // OAuth tokens are fetched. It would use incorrect Authenticator instance.
   authenticator_ = NULL;
 }
 
 void LoginUtilsImpl::OnOAuthGetAccessTokenFailure(
     const GoogleServiceAuthError& error) {
   // TODO(zelidrag): Pop up sync setup UI here?
   LOG(WARNING) << "Failed fetching OAuth v1 token, error: " << error.state();
 }
 
+void LoginUtilsImpl::OnOnlineStateChanged(bool online) {
+  // If we come online for the first time after successful offline login,
+  // we need to kick of OAuth token verification process again.
+  if (UserManager::Get()->user_is_logged_in() &&
+      UserManager::Get()->offline_login() && online) {
+    if (!authenticator_.get())
+      CreateAuthenticator(NULL);
+    std::string oauth1_token;
+    std::string oauth1_secret;
+    Profile* user_profile = ProfileManager::GetDefaultProfile();
+    if (ReadOAuth1AccessToken(user_profile, &oauth1_token, &oauth1_secret))
+      VerifyOAuth1AccessToken(user_profile, oauth1_token, oauth1_secret);
+    authenticator_ = NULL;
+  }
+}
+
 LoginUtils* LoginUtils::Get() {
   return LoginUtilsWrapper::GetInstance()->get();
 }
 
 void LoginUtils::Set(LoginUtils* mock) {
   LoginUtilsWrapper::GetInstance()->reset(mock);
 }
 
 void LoginUtils::DoBrowserLaunch(Profile* profile,
                                  LoginDisplayHost* login_host) {
@@ skipping 11 matching lines @@
   // Mark login host for deletion after browser starts.  This
   // guarantees that the message loop will be referenced by the
   // browser before it is dereferenced by the login host.
   if (login_host) {
     login_host->OnSessionStart();
     login_host = NULL;
   }
 }
 
 }  // namespace chromeos