Move RevokeCredentialsOnServer to MutableProfileOAuth2TokenService

chrome/browser/signin/mutable_profile_oauth2_token_service.cc

 // Copyright 2013 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/mutable_profile_oauth2_token_service.h"
 
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/webdata/token_web_data.h"
 #include "components/webdata/common/web_data_service_base.h"
+#include "google_apis/gaia/gaia_auth_fetcher.h"
 #include "google_apis/gaia/gaia_constants.h"
+#include "google_apis/gaia/google_service_auth_error.h"
+#include "net/url_request/url_request_context_getter.h"
 
 #if defined(ENABLE_MANAGED_USERS)
 #include "chrome/browser/managed_mode/managed_user_constants.h"
 #endif
 
 namespace {
 
 const char kAccountIdPrefix[] = "AccountId-";
 const size_t kAccountIdPrefixLength = 10;
 
 std::string ApplyAccountIdPrefix(const std::string& account_id) {
   return kAccountIdPrefix + account_id;
 }
 
 bool IsLegacyRefreshTokenId(const std::string& service_id) {
   return service_id == GaiaConstants::kGaiaOAuth2LoginRefreshToken;
 }
 
 bool IsLegacyServiceId(const std::string& account_id) {
   return account_id.compare(0u, kAccountIdPrefixLength, kAccountIdPrefix) != 0;
 }
 
 std::string RemoveAccountIdPrefix(const std::string& prefixed_account_id) {
   return prefixed_account_id.substr(kAccountIdPrefixLength);
 }
 
+// This class sends a request to GAIA to revoke the given refresh token from
+// the server.  This is a best effort attempt only.  This class deletes itself
+// when done sucessfully or otherwise.
+class RevokeServerRefreshToken : public GaiaAuthConsumer {
+ public:
+  RevokeServerRefreshToken(const std::string& account_id,
+                           net::URLRequestContextGetter* request_context);
+  virtual ~RevokeServerRefreshToken();
+
+ private:
+  // GaiaAuthConsumer overrides:
+  virtual void OnOAuth2RevokeTokenCompleted() OVERRIDE;
+
+  scoped_refptr<net::URLRequestContextGetter> request_context_;
+  scoped_ptr<GaiaAuthFetcher> fetcher_;

[Roger Tawa OOO till Jul 10th, 2013/12/19 13:43:58]

While you're here, can you change this member from:

   scoped_ptr<GaiaAuthFetcher> fetcher_;

to:

   GaiaAuthFetcher fetcher_;

I think its simpler and reduces the number of separate memory allocations.

[msarda, 2013/12/19 17:35:35]

Done.

If GaiaAuthFetcher had used a ref counted pointer to
net::URLRequestContextGetter, then we could remove |request_context_| as well. I
don't actually know why GaiaAuthFetcher doesn't use a scoped_refptr for its
request context getter.

That is a larger refactoring though, I won't do it in this CL.

+
+  DISALLOW_COPY_AND_ASSIGN(RevokeServerRefreshToken);
+};
+
+RevokeServerRefreshToken::RevokeServerRefreshToken(
+    const std::string& refresh_token,
+    net::URLRequestContextGetter* request_context)
+    : request_context_(request_context) {
+  fetcher_.reset(
+      new GaiaAuthFetcher(this,
+                          GaiaConstants::kChromeSource,
+                          request_context_.get()));
+  fetcher_->StartRevokeOAuth2Token(refresh_token);
+}
+
+RevokeServerRefreshToken::~RevokeServerRefreshToken() {}
+
+void RevokeServerRefreshToken::OnOAuth2RevokeTokenCompleted() {
+  delete this;
+}
+
 }  // namespace
 
 MutableProfileOAuth2TokenService::MutableProfileOAuth2TokenService()
     : web_data_service_request_(0)  {
 }
 
 MutableProfileOAuth2TokenService::~MutableProfileOAuth2TokenService() {
 }
 
 void MutableProfileOAuth2TokenService::Shutdown() {
   if (web_data_service_request_ != 0) {
     scoped_refptr<TokenWebData> token_web_data =
         TokenWebData::FromBrowserContext(profile());
     DCHECK(token_web_data.get());
     token_web_data->CancelRequest(web_data_service_request_);
     web_data_service_request_  = 0;
   }
   ProfileOAuth2TokenService::Shutdown();
 }
 
+net::URLRequestContextGetter*
+MutableProfileOAuth2TokenService::GetRequestContext() {
+  return profile()->GetRequestContext();
+}
+
 void MutableProfileOAuth2TokenService::LoadCredentials() {
   DCHECK_EQ(0, web_data_service_request_);
 
   CancelAllRequests();
   refresh_tokens().clear();
   scoped_refptr<TokenWebData> token_web_data =
       TokenWebData::FromBrowserContext(profile());
   if (token_web_data.get())
     web_data_service_request_ = token_web_data->GetAllTokens(this);
 }
@@ skipping 94 matching lines @@
 MutableProfileOAuth2TokenService::GetAccountIdForMigratingRefreshToken() {
 #if defined(ENABLE_MANAGED_USERS)
   // TODO(bauerb): Make sure that only services that can deal with supervised
   // users see the supervised user token.
   if (profile()->IsManaged())
     return managed_users::kManagedUserPseudoEmail;
 #endif
 
   return GetPrimaryAccountId();
 }
+
+void MutableProfileOAuth2TokenService::RevokeCredentialsOnServer(
+    const std::string& refresh_token) {
+  // RevokeServerRefreshToken deletes itself when done.
+  new RevokeServerRefreshToken(refresh_token, GetRequestContext());
+}