chrome: Use base::MessageLoop. (Part 3)

chrome/browser/signin/oauth2_token_service.cc

 // Copyright 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/signin/oauth2_token_service.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/weak_ptr.h"
@@ skipping 195 matching lines @@
   // This is intentional -- some consumers may need the token for cleanup
   // tasks. https://chromiumcodereview.appspot.com/11312124/
   oauth2_token_service_->RegisterCacheEntry(refresh_token_,
                                             scopes_,
                                             access_token_,
                                             expiration_date_);
   // Deregisters itself from the service to prevent more waiting requests to
   // be added when it calls back the waiting requests.
   oauth2_token_service_->OnFetchComplete(this);
   InformWaitingRequests();
-  MessageLoop::current()->DeleteSoon(FROM_HERE, this);
+  base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 }
 
 void OAuth2TokenService::Fetcher::OnGetTokenFailure(
     const GoogleServiceAuthError& error) {
   fetcher_.reset();
 
   if (ShouldRetry(error) && retry_number_ < kMaxFetchRetryNum) {
     int64 backoff = ComputeExponentialBackOffMilliseconds(retry_number_);
     ++retry_number_;
     retry_timer_.Stop();
     retry_timer_.Start(FROM_HERE,
                        base::TimeDelta::FromMilliseconds(backoff),
                        this,
                        &OAuth2TokenService::Fetcher::Start);
     return;
   }
 
   // Fetch completes.
   error_ = error;
 
   // Deregisters itself from the service to prevent more waiting requests to be
   // added when it calls back the waiting requests.
   oauth2_token_service_->OnFetchComplete(this);
   InformWaitingRequests();
-  MessageLoop::current()->DeleteSoon(FROM_HERE, this);
+  base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 }
 
 // static
 bool OAuth2TokenService::Fetcher::ShouldRetry(
     const GoogleServiceAuthError& error) {
   GoogleServiceAuthError::State error_state = error.state();
   return error_state == GoogleServiceAuthError::CONNECTION_FAILED ||
          error_state == GoogleServiceAuthError::REQUEST_CANCELED ||
          error_state == GoogleServiceAuthError::SERVICE_UNAVAILABLE;
 }
@@ skipping 65 matching lines @@
 
 scoped_ptr<OAuth2TokenService::Request> OAuth2TokenService::StartRequest(
     const OAuth2TokenService::ScopeSet& scopes,
     OAuth2TokenService::Consumer* consumer) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   scoped_ptr<RequestImpl> request(new RequestImpl(consumer));
 
   std::string refresh_token = GetRefreshToken();
   if (refresh_token.empty()) {
-    MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
-        &OAuth2TokenService::InformConsumer,
-        request->AsWeakPtr(),
-        GoogleServiceAuthError(
-            GoogleServiceAuthError::USER_NOT_SIGNED_UP),
-        std::string(),
-        base::Time()));
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(
+            &OAuth2TokenService::InformConsumer,
+            request->AsWeakPtr(),
+            GoogleServiceAuthError(GoogleServiceAuthError::USER_NOT_SIGNED_UP),
+            std::string(),
+            base::Time()));
     return request.PassAs<Request>();
   }
 
   if (HasCacheEntry(scopes))
     return StartCacheLookupRequest(scopes, consumer);
 
   // Makes sure there is a pending fetcher for |scopes| and |refresh_token|.
   // Adds |request| to the waiting request list of this fetcher so |request|
   // will be called back when this fetcher finishes fetching.
   FetchParameters fetch_parameters = std::make_pair(refresh_token, scopes);
   std::map<FetchParameters, Fetcher*>::iterator iter =
       pending_fetchers_.find(fetch_parameters);
   if (iter != pending_fetchers_.end()) {
     iter->second->AddWaitingRequest(request->AsWeakPtr());
     return request.PassAs<Request>();
   }
   pending_fetchers_[fetch_parameters] = Fetcher::CreateAndStart(
       this, request_context_getter_, refresh_token, scopes,
       request->AsWeakPtr());
   return request.PassAs<Request>();
 }
 
 scoped_ptr<OAuth2TokenService::Request>
     OAuth2TokenService::StartCacheLookupRequest(
         const OAuth2TokenService::ScopeSet& scopes,
         OAuth2TokenService::Consumer* consumer) {
   CHECK(HasCacheEntry(scopes));
   const CacheEntry* cache_entry = GetCacheEntry(scopes);
   scoped_ptr<RequestImpl> request(new RequestImpl(consumer));
-  MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
-      &OAuth2TokenService::InformConsumer,
-      request->AsWeakPtr(),
-      GoogleServiceAuthError(GoogleServiceAuthError::NONE),
-      cache_entry->access_token,
-      cache_entry->expiration_date));
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&OAuth2TokenService::InformConsumer,
+                 request->AsWeakPtr(),
+                 GoogleServiceAuthError(GoogleServiceAuthError::NONE),
+                 cache_entry->access_token,
+                 cache_entry->expiration_date));
   return request.PassAs<Request>();
 }
 
 void OAuth2TokenService::InvalidateToken(const ScopeSet& scopes,
                                          const std::string& invalid_token) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   RemoveCacheEntry(scopes, invalid_token);
 }
 
 void OAuth2TokenService::OnFetchComplete(Fetcher* fetcher) {
@@ skipping 86 matching lines @@
 }
 
 void OAuth2TokenService::ClearCache() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   token_cache_.clear();
 }
 
 int OAuth2TokenService::cache_size_for_testing() const {
   return token_cache_.size();
 }