Show GAIA/cookie accounts on the signin-internals page.

components/signin/core/browser/about_signin_internals.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 "components/signin/core/browser/about_signin_internals.h"
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/hash.h"
 #include "base/i18n/time_formatting.h"
 #include "base/logging.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
 #include "components/signin/core/browser/signin_client.h"
 #include "components/signin/core/browser/signin_internals_util.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "components/signin/core/common/profile_management_switches.h"
 #include "components/signin/core/common/signin_switches.h"
+#include "google_apis/gaia/gaia_auth_fetcher.h"
+#include "google_apis/gaia/gaia_auth_util.h"
 #include "google_apis/gaia/gaia_constants.h"
+#include "google_apis/gaia/gaia_urls.h"
+#include "net/cookies/canonical_cookie.h"
 
 using base::Time;
 using namespace signin_internals_util;
 
 namespace {
 
 std::string GetTimeStr(base::Time time) {
   return base::UTF16ToUTF8(base::TimeFormatShortDateAndTime(time));
 }
 
@@ skipping 12 matching lines @@
                      const std::string& field_name,
                      const std::string& field_status,
                      const std::string& field_time = "") {
   scoped_ptr<base::DictionaryValue> entry(new base::DictionaryValue());
   entry->SetString("label", field_name);
   entry->SetString("status", field_status);
   entry->SetString("time", field_time);
   section_list->Append(entry.release());
 }
 
+void AddCookieEntry(base::ListValue* accounts_list,
+                     const std::string& field_email,
+                     const std::string& field_valid) {
+  scoped_ptr<base::DictionaryValue> entry(new base::DictionaryValue());
+  entry->SetString("email", field_email);
+  entry->SetString("valid", field_valid);
+  accounts_list->Append(entry.release());
+}
+
 std::string SigninStatusFieldToLabel(UntimedSigninStatusField field) {
   switch (field) {
     case USERNAME:
       return "User Id";
     case UNTIMED_FIELDS_END:
       NOTREACHED();
       return std::string();
   }
   NOTREACHED();
   return std::string();
@@ skipping 124 matching lines @@
 }
 
 void AboutSigninInternals::Initialize(SigninClient* client) {
   DCHECK(!client_);
   client_ = client;
 
   RefreshSigninPrefs();
 
   signin_manager_->AddSigninDiagnosticsObserver(this);
   token_service_->AddDiagnosticsObserver(this);
+  cookie_changed_subscription_ = client_->AddCookieChangedCallback(
+     base::Bind(&AboutSigninInternals::OnCookieChanged,
+     base::Unretained(this)));
 }
 
 void AboutSigninInternals::Shutdown() {
   signin_manager_->RemoveSigninDiagnosticsObserver(this);
   token_service_->RemoveDiagnosticsObserver(this);
+  cookie_changed_subscription_.reset();
 }
 
 void AboutSigninInternals::NotifyObservers() {
   FOR_EACH_OBSERVER(AboutSigninInternals::Observer,
                     signin_observers_,
                     OnSigninStateChanged(
                         signin_status_.ToValue(client_->GetProductVersion())));
 }
 
 scoped_ptr<base::DictionaryValue> AboutSigninInternals::GetSigninStatus() {
@@ skipping 47 matching lines @@
 }
 
 void AboutSigninInternals::OnRefreshTokenReceived(std::string status) {
   NotifySigninValueChanged(REFRESH_TOKEN_RECEIVED, status);
 }
 
 void AboutSigninInternals::OnAuthenticationResultReceived(std::string status) {
   NotifySigninValueChanged(AUTHENTICATION_RESULT_RECEIVED, status);
 }
 
+void AboutSigninInternals::OnCookieChanged(
+    const net::CanonicalCookie* cookie) {
+  if (cookie->Name() == "LSID" &&
+      cookie->Domain() == GaiaUrls::GetInstance()->gaia_url().host() &&
+      cookie->IsSecure() &&
+      cookie->IsHttpOnly()) {
+    GetCookieAccountsAsync();
+  }
+}
+
+void AboutSigninInternals::GetCookieAccountsAsync() {
+  if (!gaia_fetcher_) {
+    // There is no list account request in flight.
+    gaia_fetcher_.reset(new GaiaAuthFetcher(
+        this, GaiaConstants::kChromeSource, client_->GetURLRequestContext()));
+    gaia_fetcher_->StartListAccounts();
+  }
+}
+
+void AboutSigninInternals::OnListAccountsSuccess(const std::string& data) {
+  gaia_fetcher_.reset();
+
+  // Get account information from response data.
+  std::vector<std::pair<std::string, bool> > gaia_accounts;
+  bool valid_json = gaia::ParseListAccountsData(data, &gaia_accounts);
+  if (!valid_json) {
+    VLOG(1) << "AboutSigninInternals::OnListAccountsSuccess: parsing error";
+  } else {
+    OnListAccountsComplete(gaia_accounts);
+  }
+}
+
+void AboutSigninInternals::OnListAccountsFailure(
+    const GoogleServiceAuthError& error) {
+  gaia_fetcher_.reset();
+  VLOG(1) << "AboutSigninInternals::OnListAccountsFailure:" << error.ToString();
+}
+
+void AboutSigninInternals::OnListAccountsComplete(
+    std::vector<std::pair<std::string, bool> >& gaia_accounts) {
+  scoped_ptr<base::DictionaryValue> signin_status(new base::DictionaryValue());
+  base::ListValue* cookie_info = new base::ListValue();
+  signin_status->Set("cookie_info", cookie_info);
+
+  for (size_t i = 0; i < gaia_accounts.size(); ++i) {
+    AddCookieEntry(cookie_info,
+                   gaia_accounts[i].first,
+                   gaia_accounts[i].second ? "Valid" : "Invalid");
+  }
+
+  if (gaia_accounts.size() == 0)
+    AddCookieEntry(cookie_info, "No Accounts Present.", "");
+
+  // Update the observers that the cookie's accounts are updated.
+  FOR_EACH_OBSERVER(AboutSigninInternals::Observer,
+                    signin_observers_,
+                    OnCookieAccountsFetched(signin_status.Pass()));
+}
+
 AboutSigninInternals::TokenInfo::TokenInfo(
     const std::string& consumer_id,
     const OAuth2TokenService::ScopeSet& scopes)
     : consumer_id(consumer_id),
       scopes(scopes),
       request_time(base::Time::Now()),
       error(GoogleServiceAuthError::AuthErrorNone()),
       removed_(false) {}
 
 AboutSigninInternals::TokenInfo::~TokenInfo() {}
@@ skipping 125 matching lines @@
     std::sort(it->second.begin(), it->second.end(), TokenInfo::LessThan);
     const std::vector<TokenInfo*>& tokens = it->second;
     for (size_t i = 0; i < tokens.size(); ++i) {
       base::DictionaryValue* token_info = tokens[i]->ToValue();
       token_details->Append(token_info);
     }
   }
 
   return signin_status.Pass();
 }