Making OAuth2TokenService multi-login aware, updating callers, minor fixes

chrome/browser/managed_mode/managed_user_refresh_token_fetcher_unittest.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 "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/managed_mode/managed_user_refresh_token_fetcher.h"
 #include "chrome/browser/signin/oauth2_token_service.h"
 #include "chrome/test/base/testing_profile.h"
@@ skipping 57 matching lines @@
   MockOAuth2TokenService();
   virtual ~MockOAuth2TokenService();
 
   Request* request() const { return request_; }
 
   void ClearRequest(Request* request);
 
  private:
   // OAuth2TokenService overrides:
   virtual scoped_ptr<OAuth2TokenService::Request> StartRequest(
-     const OAuth2TokenService::ScopeSet& scopes,
+      const std::string& account_id,
+      const OAuth2TokenService::ScopeSet& scopes,
       OAuth2TokenService::Consumer* consumer) OVERRIDE;
-  virtual std::string GetRefreshToken() OVERRIDE;
+  virtual std::string GetRefreshToken(const std::string& account_id) OVERRIDE;
   virtual net::URLRequestContextGetter* GetRequestContext() OVERRIDE {
     return NULL;
   }
 
   Request* request_;
 
   DISALLOW_COPY_AND_ASSIGN(MockOAuth2TokenService);
 };
 
 MockOAuth2TokenService::Request::Request(
@@ skipping 25 matching lines @@
   EXPECT_FALSE(request_);
 }
 
 void MockOAuth2TokenService::ClearRequest(
     MockOAuth2TokenService::Request* request) {
   if (request_ == request)
     request_ = NULL;
 }
 
 scoped_ptr<OAuth2TokenService::Request> MockOAuth2TokenService::StartRequest(
+      const std::string& account_id,
     const OAuth2TokenService::ScopeSet& scopes,
     OAuth2TokenService::Consumer* consumer) {
   scoped_ptr<Request> request(new Request(scopes, consumer, this));
   request_ = request.get();
   return request.PassAs<OAuth2TokenService::Request>();
 }
 
-std::string MockOAuth2TokenService::GetRefreshToken() {
+std::string MockOAuth2TokenService::GetRefreshToken(
+    const std::string& account_id) {
   NOTREACHED();
   return std::string();
 }
 
 // Utility methods --------------------------------------------------
 
 // Slightly hacky way to extract a value from a URL-encoded POST request body.
 bool GetValueForKey(const std::string& encoded_string,
                     const std::string& key,
                     std::string* value) {
@@ skipping 55 matching lines @@
   scoped_ptr<ManagedUserRefreshTokenFetcher> token_fetcher_;
 
   GoogleServiceAuthError error_;
   std::string token_;
   base::WeakPtrFactory<ManagedUserRefreshTokenFetcherTest> weak_ptr_factory_;
 };
 
 ManagedUserRefreshTokenFetcherTest::ManagedUserRefreshTokenFetcherTest()
     : token_fetcher_(
           ManagedUserRefreshTokenFetcher::Create(&oauth2_token_service_,
-                                          profile_.GetRequestContext())),
+                                                 std::string(),
+                                                 profile_.GetRequestContext())),
       error_(GoogleServiceAuthError::NONE),
       weak_ptr_factory_(this) {}
 
 void ManagedUserRefreshTokenFetcherTest::StartFetching() {
   token_fetcher_->Start(kManagedUserId, kDeviceName,
                         base::Bind(
                             &ManagedUserRefreshTokenFetcherTest::OnTokenFetched,
                             weak_ptr_factory_.GetWeakPtr()));
 }
 
@@ skipping 192 matching lines @@
 
 TEST_F(ManagedUserRefreshTokenFetcherTest, CancelWhileFetchingRefreshToken) {
   StartFetching();
   GetOAuth2TokenServiceRequest()->Succeed();
   MakeIssueTokenRequestSucceed();
   Reset();
 
   EXPECT_EQ(GoogleServiceAuthError::NONE, error().state());
   EXPECT_EQ(std::string(), token());
 }