Make push messaging not create InvalidationService for login and guest

chrome/browser/extensions/api/push_messaging/push_messaging_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/push_messaging/push_messaging_api.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
@@ skipping 24 matching lines @@
 #include "extensions/common/extension.h"
 #include "extensions/common/permissions/api_permission.h"
 #include "google_apis/gaia/gaia_constants.h"
 
 using content::BrowserThread;
 
 const char kChannelIdSeparator[] = "/";
 const char kUserNotSignedIn[] = "The user is not signed in.";
 const char kUserAccessTokenFailure[] =
     "Cannot obtain access token for the user.";
+const char kAPINotAvailableForUser[] =
+    "The API is not available for this user.";
 const int kObfuscatedGaiaIdTimeoutInDays = 30;
 
 namespace extensions {
 
 namespace glue = api::push_messaging;
 
 PushMessagingEventRouter::PushMessagingEventRouter(Profile* profile)
     : profile_(profile) {
 }
 
@@ skipping 40 matching lines @@
       glue::GetChannelId::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   if (params && params->interactive) {
     interactive_ = *params->interactive;
   }
 
   // Balanced in ReportResult()
   AddRef();
 
-  if (!IsUserLoggedIn()) {
-    invalidation::InvalidationAuthProvider* auth_provider =
-        GetInvalidationAuthProvider();
+  invalidation::InvalidationService* invalidation_service =
+      invalidation::InvalidationServiceFactory::GetForProfile(GetProfile());
+  if (!invalidation_service) {
+    error_ = kAPINotAvailableForUser;
+    ReportResult(std::string(), error_);
+    return false;
+  }
+
+  invalidation::InvalidationAuthProvider* auth_provider =
+      invalidation_service->GetInvalidationAuthProvider();
+  if (!auth_provider->GetTokenService()->RefreshTokenIsAvailable(
+          auth_provider->GetAccountId())) {
     if (interactive_ && auth_provider->ShowLoginUI()) {
       auth_provider->GetTokenService()->AddObserver(this);
       return true;
     } else {
       error_ = kUserNotSignedIn;
       ReportResult(std::string(), error_);
       return false;
     }
   }
 
   DVLOG(2) << "Logged in profile name: " << GetProfile()->GetProfileName();
 
   StartAccessTokenFetch();
   return true;
 }
 
 void PushMessagingGetChannelIdFunction::StartAccessTokenFetch() {
+  invalidation::InvalidationService* invalidation_service =
+      invalidation::InvalidationServiceFactory::GetForProfile(GetProfile());
+  CHECK(invalidation_service);
+  invalidation::InvalidationAuthProvider* auth_provider =
+      invalidation_service->GetInvalidationAuthProvider();
+
   std::vector<std::string> scope_vector =
       extensions::ObfuscatedGaiaIdFetcher::GetScopes();
   OAuth2TokenService::ScopeSet scopes(scope_vector.begin(), scope_vector.end());
-  invalidation::InvalidationAuthProvider* auth_provider =
-      GetInvalidationAuthProvider();
   fetcher_access_token_request_ =
       auth_provider->GetTokenService()->StartRequest(
           auth_provider->GetAccountId(), scopes, this);
 }
 
 void PushMessagingGetChannelIdFunction::OnRefreshTokenAvailable(
     const std::string& account_id) {
-  GetInvalidationAuthProvider()->GetTokenService()->RemoveObserver(this);
+  invalidation::InvalidationService* invalidation_service =
+      invalidation::InvalidationServiceFactory::GetForProfile(GetProfile());
+  CHECK(invalidation_service);
+  invalidation_service->GetInvalidationAuthProvider()->GetTokenService()->
+      RemoveObserver(this);
   DVLOG(2) << "Newly logged in: " << GetProfile()->GetProfileName();
   StartAccessTokenFetch();
 }
 
 void PushMessagingGetChannelIdFunction::OnGetTokenSuccess(
     const OAuth2TokenService::Request* request,
     const std::string& access_token,
     const base::Time& expiration_time) {
   DCHECK_EQ(fetcher_access_token_request_.get(), request);
   fetcher_access_token_request_.reset();
@@ skipping 32 matching lines @@
   const std::string& gaia_id =
       token_cache->RetrieveToken(GaiaConstants::kObfuscatedGaiaId);
   if (!gaia_id.empty()) {
     ReportResult(gaia_id, std::string());
     return;
   }
 
   fetcher_->Start();
 }
 
-// Check if the user is logged in.
-bool PushMessagingGetChannelIdFunction::IsUserLoggedIn() {
-  invalidation::InvalidationAuthProvider* auth_provider =
-      GetInvalidationAuthProvider();
-  return auth_provider->GetTokenService()->RefreshTokenIsAvailable(
-      auth_provider->GetAccountId());
-}
-
 void PushMessagingGetChannelIdFunction::ReportResult(
     const std::string& gaia_id, const std::string& error_string) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   BuildAndSendResult(gaia_id, error_string);
 
   // Cache the obfuscated ID locally. It never changes for this user,
   // and if we call the web API too often, we get errors due to rate limiting.
   if (!gaia_id.empty()) {
     base::TimeDelta timeout =
@@ skipping 45 matching lines @@
     error_text = base::IntToString(error.state());
   }
 
   DVLOG(1) << "GetChannelId status: '" << error_text << "'";
 
   // If we had bad credentials, try the logon again.
   switch (error.state()) {
     case GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS:
     case GoogleServiceAuthError::ACCOUNT_DELETED:
     case GoogleServiceAuthError::ACCOUNT_DISABLED: {
-      if (!interactive_ || !GetInvalidationAuthProvider()->ShowLoginUI()) {
+      invalidation::InvalidationService* invalidation_service =
+          invalidation::InvalidationServiceFactory::GetForProfile(GetProfile());
+      CHECK(invalidation_service);
+      if (!interactive_ ||
+          !invalidation_service->GetInvalidationAuthProvider()->ShowLoginUI()) {
         ReportResult(std::string(), error_text);
       }
       return;
     }
     default:
       // Return error to caller.
       ReportResult(std::string(), error_text);
       return;
   }
 }
 
-invalidation::InvalidationAuthProvider*
-PushMessagingGetChannelIdFunction::GetInvalidationAuthProvider() {
-  return invalidation::InvalidationServiceFactory::GetForProfile(GetProfile())
-      ->GetInvalidationAuthProvider();
-}
-
 PushMessagingAPI::PushMessagingAPI(content::BrowserContext* context)
     : profile_(Profile::FromBrowserContext(context)) {
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_INSTALLED,
                  content::Source<Profile>(profile_->GetOriginalProfile()));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
                  content::Source<Profile>(profile_->GetOriginalProfile()));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED,
                  content::Source<Profile>(profile_->GetOriginalProfile()));
 }
 
@@ skipping 17 matching lines @@
 BrowserContextKeyedAPIFactory<PushMessagingAPI>*
 PushMessagingAPI::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 void PushMessagingAPI::Observe(int type,
                                const content::NotificationSource& source,
                                const content::NotificationDetails& details) {
   invalidation::InvalidationService* invalidation_service =
       invalidation::InvalidationServiceFactory::GetForProfile(profile_);
-  // This may be NULL; for example, for the ChromeOS guest user. In these cases,
-  // just return without setting up anything, since it won't work anyway.
   if (!invalidation_service)
     return;
 
   if (!event_router_)
     event_router_.reset(new PushMessagingEventRouter(profile_));
   if (!handler_) {
     handler_.reset(new PushMessagingInvalidationHandler(
         invalidation_service, event_router_.get()));
   }
   switch (type) {
@@ skipping 31 matching lines @@
 }
 
 template <>
 void
 BrowserContextKeyedAPIFactory<PushMessagingAPI>::DeclareFactoryDependencies() {
   DependsOn(ExtensionsBrowserClient::Get()->GetExtensionSystemFactory());
   DependsOn(invalidation::InvalidationServiceFactory::GetInstance());
 }
 
 }  // namespace extensions