Identity API: add chrome.identity.getAccounts

chrome/browser/extensions/api/identity/identity_api.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/extensions/api/identity/identity_api.h"
 
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 10 matching lines @@
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/browser/signin/signin_global_error.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/common/extensions/api/identity.h"
 #include "chrome/common/extensions/api/identity/oauth2_manifest_handler.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
 #include "components/signin/core/browser/signin_manager.h"
+#include "components/signin/core/common/profile_management_switches.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_function_dispatcher.h"
 #include "extensions/common/extension.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "url/gurl.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
 #include "chrome/browser/chromeos/settings/device_oauth2_token_service.h"
@@ skipping 120 matching lines @@
 
 const IdentityTokenCacheValue& IdentityAPI::GetCachedToken(
     const ExtensionTokenKey& key) {
   return token_cache_[key];
 }
 
 const IdentityAPI::CachedTokens& IdentityAPI::GetAllCachedTokens() {
   return token_cache_;
 }
 
+std::vector<std::string> IdentityAPI::GetAccounts() const {
+  const std::vector<AccountIds> ids = account_tracker_.GetAccounts();
+  std::vector<std::string> gaia_ids;
+
+  if (switches::IsExtensionsMultiAccount()) {
+    for (std::vector<AccountIds>::const_iterator it = ids.begin();
+         it != ids.end();
+         ++it) {
+      gaia_ids.push_back(it->gaia);
+    }
+  } else if (ids.size() >= 1) {
+    gaia_ids.push_back(ids[0].gaia);
+  }
+
+  return gaia_ids;
+}
+
 void IdentityAPI::ReportAuthError(const GoogleServiceAuthError& error) {
   account_tracker_.ReportAuthError(GetPrimaryAccountId(browser_context_),
                                    error);
 }
 
 GoogleServiceAuthError IdentityAPI::GetAuthStatusForTest() const {
   return account_tracker_.GetAuthStatus();
 }
 
 void IdentityAPI::Shutdown() {
   FOR_EACH_OBSERVER(ShutdownObserver, shutdown_observer_list_, OnShutdown());
   account_tracker_.RemoveObserver(this);
   account_tracker_.Shutdown();
 }
 
 static base::LazyInstance<BrowserContextKeyedAPIFactory<IdentityAPI> >
     g_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<IdentityAPI>* IdentityAPI::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 void IdentityAPI::OnAccountAdded(const AccountIds& ids) {}
 
 void IdentityAPI::OnAccountRemoved(const AccountIds& ids) {}
 
 void IdentityAPI::OnAccountSignInChanged(const AccountIds& ids,
                                          bool is_signed_in) {
+  const std::string primary_account_id = GetPrimaryAccountId(browser_context_);
+  if (primary_account_id != ids.account_key &&
+      !switches::IsExtensionsMultiAccount()) {
+    return;
+  }
+
   api::identity::AccountInfo account_info;
   account_info.id = ids.gaia;
 
   scoped_ptr<base::ListValue> args =
       api::identity::OnSignInChanged::Create(account_info, is_signed_in);
   scoped_ptr<Event> event(new Event(api::identity::OnSignInChanged::kEventName,
                                     args.Pass(),
                                     browser_context_));
 
   EventRouter::Get(browser_context_)->BroadcastEvent(event.Pass());
 }
 
 void IdentityAPI::AddShutdownObserver(ShutdownObserver* observer) {
   shutdown_observer_list_.AddObserver(observer);
 }
 
 void IdentityAPI::RemoveShutdownObserver(ShutdownObserver* observer) {
   shutdown_observer_list_.RemoveObserver(observer);
 }
 
+void IdentityAPI::SetAccountStateForTest(AccountIds ids, bool is_signed_in) {
+  account_tracker_.SetAccountStateForTest(ids, is_signed_in);
+}
+
 template <>
 void BrowserContextKeyedAPIFactory<IdentityAPI>::DeclareFactoryDependencies() {
   DependsOn(ExtensionsBrowserClient::Get()->GetExtensionSystemFactory());
   DependsOn(ProfileOAuth2TokenServiceFactory::GetInstance());
 }
 
+IdentityGetAccountsFunction::IdentityGetAccountsFunction() {
+}
+
+IdentityGetAccountsFunction::~IdentityGetAccountsFunction() {
+}
+
+ExtensionFunction::ResponseAction IdentityGetAccountsFunction::Run() {
+  if (GetProfile()->IsOffTheRecord()) {
+    return RespondNow(Error(identity_constants::kOffTheRecord));
+  }
+
+  std::vector<std::string> gaia_ids =
+      IdentityAPI::GetFactoryInstance()->Get(GetProfile())->GetAccounts();
+  DCHECK(gaia_ids.size() < 2 || switches::IsExtensionsMultiAccount());
+
+  base::ListValue* infos = new base::ListValue();
+
+  for (std::vector<std::string>::const_iterator it = gaia_ids.begin();
+       it != gaia_ids.end();
+       ++it) {
+    api::identity::AccountInfo account_info;
+    account_info.id = *it;
+    infos->Append(account_info.ToValue().release());
+  }
+
+  return RespondNow(MultipleArguments(infos));
+}
+
 IdentityGetAuthTokenFunction::IdentityGetAuthTokenFunction()
     : OAuth2TokenService::Consumer("extensions_identity_api"),
       should_prompt_for_scopes_(false),
       should_prompt_for_signin_(false) {}
 
 IdentityGetAuthTokenFunction::~IdentityGetAuthTokenFunction() {}
 
 bool IdentityGetAuthTokenFunction::RunAsync() {
   if (GetProfile()->IsOffTheRecord()) {
     error_ = identity_constants::kOffTheRecord;
@@ skipping 537 matching lines @@
 void IdentityLaunchWebAuthFlowFunction::OnAuthFlowURLChange(
     const GURL& redirect_url) {
   if (redirect_url.GetWithEmptyPath() == final_url_prefix_) {
     SetResult(new base::StringValue(redirect_url.spec()));
     SendResponse(true);
     Release();  // Balanced in RunAsync.
   }
 }
 
 }  // namespace extensions