[signin] Support for CrOS and OAuth2AccessTokenConsumer services.

chrome/browser/chromeos/login/online_attempt.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/chromeos/login/online_attempt.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/login/auth_attempt_state.h"
 #include "chrome/browser/chromeos/login/auth_attempt_state_resolver.h"
 #include "chrome/browser/chromeos/login/user.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
+#include "chrome/browser/signin/about_signin_internals.h"
+#include "chrome/browser/signin/about_signin_internals_factory.h"
 #include "content/public/browser/browser_thread.h"
 #include "google_apis/gaia/gaia_auth_consumer.h"
 #include "google_apis/gaia/gaia_auth_fetcher.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/url_request_status.h"
 #include "third_party/libjingle/source/talk/base/urlencode.h"
 
 using content::BrowserThread;
+using namespace signin_internals_util;
 
 namespace {
 
 // The service scope of the OAuth v2 token that ChromeOS login will be
 // requesting.
 const char kServiceScopeChromeOS[] =
     "https://www.googleapis.com/auth/chromesync";
 
+#define FOR_DIAGNOSTICS_OBSERVERS(func)                               \
+  do {                                                                \
+    FOR_EACH_OBSERVER(SigninDiagnosticsObserver,                      \
+                      signin_diagnostics_observers_,                  \
+                      func);                                          \
+  } while (0)                                                         \
+
 }
 
 namespace chromeos {
 
 // static
 const int OnlineAttempt::kClientLoginTimeoutMs = 10000;
 
 OnlineAttempt::OnlineAttempt(bool using_oauth,
                              AuthAttemptState* current_attempt,
                              AuthAttemptStateResolver* callback)
@@ skipping 25 matching lines @@
     client_fetcher_.reset(
         new GaiaAuthFetcher(this, GaiaConstants::kChromeOSSource,
                             auth_profile->GetRequestContext()));
   }
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&OnlineAttempt::TryClientLogin, weak_factory_.GetWeakPtr()));
 }
 
 void OnlineAttempt::OnClientLoginSuccess(
-    const GaiaAuthConsumer::ClientLoginResult& unused) {
+    const GaiaAuthConsumer::ClientLoginResult& result) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   VLOG(1) << "Online login successful!";
 
   weak_factory_.InvalidateWeakPtrs();
 
   if (attempt_->hosted_policy() == GaiaAuthFetcher::HostedAccountsAllowed &&
       attempt_->is_first_time_user()) {
     // First time user, and we don't know if the account is HOSTED or not.
     // Since we don't allow HOSTED accounts to log in, we need to try
     // again, without allowing HOSTED accounts.
     //
     // NOTE: we used to do this in the opposite order, so that we'd only
     // try the HOSTED pathway if GOOGLE-only failed.  This breaks CAPTCHA
     // handling, though.
     attempt_->DisableHosted();
     TryClientLogin();
     return;
   }
+
+  // Inform all signin diagnostics observers about the login.
+  FOR_DIAGNOSTICS_OBSERVERS(NotifySigninValueChanged(
+      USERNAME, UserManager::Get()->GetLoggedInUser()->email()));
+  FOR_DIAGNOSTICS_OBSERVERS(NotifySigninValueChanged(
+      SIGNIN_TYPE, "Client Login"));
+  FOR_DIAGNOSTICS_OBSERVERS(NotifySigninValueChanged(
+      LSID, result.lsid));
+  FOR_DIAGNOSTICS_OBSERVERS(NotifySigninValueChanged(
+      SID, result.sid));
+
   TriggerResolve(LoginFailure::None());
 }
 
 void OnlineAttempt::OnClientLoginFailure(
     const GoogleServiceAuthError& error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   weak_factory_.InvalidateWeakPtrs();
 
   if (error.state() == GoogleServiceAuthError::REQUEST_CANCELED) {
     if (try_again_) {
       try_again_ = false;
       // TODO(cmasone): add UMA tracking for this to see if we can remove it.
       LOG(ERROR) << "Login attempt canceled!?!?  Trying again.";
+
+      // Inform all signin diagnostics observers about the retry
+      FOR_DIAGNOSTICS_OBSERVERS(NotifySigninValueChanged(
+          CLIENT_LOGIN_STATUS, "Login Canceled. Retrying."));
+
       TryClientLogin();
       return;
     }
+    // Inform all signin diagnostics observers about the cancellation.
+    FOR_DIAGNOSTICS_OBSERVERS(NotifySigninValueChanged(
+        CLIENT_LOGIN_STATUS, "Login Canceled (after retry)"));
+
     LOG(ERROR) << "Login attempt canceled again?  Already retried...";
   }
 
   if (error.state() == GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS &&
       attempt_->is_first_time_user() &&
       attempt_->hosted_policy() != GaiaAuthFetcher::HostedAccountsAllowed) {
     // This was a first-time login, we already tried allowing HOSTED accounts
     // and succeeded.  That we've failed with INVALID_GAIA_CREDENTIALS now
     // indicates that the account is HOSTED.
     LOG(WARNING) << "Rejecting valid HOSTED account.";
+
+    // Inform all signin diagnostics observers about the login.
+    FOR_DIAGNOSTICS_OBSERVERS(NotifySigninValueChanged(
+        CLIENT_LOGIN_STATUS, "Rejecting valid HOSTED account"));
+
     TriggerResolve(LoginFailure::FromNetworkAuthFailure(
                        GoogleServiceAuthError(
                            GoogleServiceAuthError::HOSTED_NOT_ALLOWED)));
     return;
   }
 
   if (error.state() == GoogleServiceAuthError::TWO_FACTOR) {
     LOG(WARNING) << "Two factor authenticated. Sync will not work.";
+
+    // Inform all signin diagnostics observers about the login.
+    // TODO(vishwath): Is this really a successful login?
+    FOR_DIAGNOSTICS_OBSERVERS(NotifySigninValueChanged(
+        SIGNIN_TYPE, "Client Login (with two factor authentication)"));
+    FOR_DIAGNOSTICS_OBSERVERS(NotifySigninValueChanged(
+        CLIENT_LOGIN_STATUS, "Successful"));
+
+
     TriggerResolve(LoginFailure::None());
-
     return;
   }
+
+
+  FOR_DIAGNOSTICS_OBSERVERS(NotifySigninValueChanged(
+      SIGNIN_TYPE, "Client Login"));
+
   VLOG(2) << "ClientLogin attempt failed with " << error.state();
   TriggerResolve(LoginFailure::FromNetworkAuthFailure(error));
 }
 
 void OnlineAttempt::OnOAuthLoginSuccess(const std::string& sid,
                                         const std::string& lsid,
                                         const std::string& auth) {
   GaiaAuthConsumer::ClientLoginResult credentials(sid,
     lsid, auth, std::string());
   OnClientLoginSuccess(credentials);
@@ skipping 57 matching lines @@
 
 void OnlineAttempt::TriggerResolve(
     const LoginFailure& outcome) {
   attempt_->RecordOnlineLoginStatus(outcome);
   client_fetcher_.reset(NULL);
   oauth_fetcher_.reset(NULL);
   resolver_->Resolve();
 }
 
 }  // namespace chromeos