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

chrome/browser/signin/profile_oauth2_token_service_request_unittest.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/profile_oauth2_token_service_request.h"
 
 #include <set>
 #include <string>
 #include <vector>
 #include "base/threading/thread.h"
 #include "chrome/browser/signin/profile_oauth2_token_service.h"
@@ skipping 64 matching lines @@
     OAuth2TokenService::Consumer* consumer_;
     GoogleServiceAuthError error_;
     std::string access_token_;
     base::Time expiration_date_;
   };
 
   MockProfileOAuth2TokenService();
   virtual ~MockProfileOAuth2TokenService();
 
   virtual scoped_ptr<OAuth2TokenService::Request> StartRequest(
-      const std::set<std::string>& scopes,
+      const std::string& account_id,
+      const OAuth2TokenService::ScopeSet& scopes,
       OAuth2TokenService::Consumer* consumer) OVERRIDE;
 
   void SetExpectation(bool success, std::string oauth2_access_token);
 
  private:
   static void InformConsumer(
       base::WeakPtr<MockProfileOAuth2TokenService::Request> request);
 
   bool success_;
   std::string oauth2_access_token_;
@@ skipping 19 matching lines @@
 }
 
 MockProfileOAuth2TokenService::MockProfileOAuth2TokenService()
     : success_(true),
       oauth2_access_token_(std::string("success token")) {
 }
 
 MockProfileOAuth2TokenService::~MockProfileOAuth2TokenService() {
 }
 
-void MockProfileOAuth2TokenService::SetExpectation(bool success,
-                                            std::string oauth2_access_token) {
+void MockProfileOAuth2TokenService::SetExpectation(
+    bool success,
+    std::string oauth2_access_token) {
   success_ = success;
   oauth2_access_token_ = oauth2_access_token;
 }
 
 // static
 void MockProfileOAuth2TokenService::InformConsumer(
     base::WeakPtr<MockProfileOAuth2TokenService::Request> request) {
   if (request.get())
     request->InformConsumer();
 }
 
 scoped_ptr<OAuth2TokenService::Request>
     MockProfileOAuth2TokenService::StartRequest(
-        const std::set<std::string>& scopes,
+        const std::string& account_id,
+        const OAuth2TokenService::ScopeSet& scopes,
         OAuth2TokenService::Consumer* consumer) {
   scoped_ptr<Request> request;
   if (success_) {
     request.reset(new MockProfileOAuth2TokenService::Request(
         consumer,
         GoogleServiceAuthError(GoogleServiceAuthError::NONE),
         oauth2_access_token_));
   } else {
     request.reset(new MockProfileOAuth2TokenService::Request(
         consumer,
@@ skipping 38 matching lines @@
   oauth2_service_ = (MockProfileOAuth2TokenService*)
       ProfileOAuth2TokenServiceFactory::GetForProfile(profile_.get());
 }
 
 TEST_F(ProfileOAuth2TokenServiceRequestTest,
        Failure) {
   oauth2_service_->SetExpectation(false, std::string());
   scoped_ptr<ProfileOAuth2TokenServiceRequest> request(
       ProfileOAuth2TokenServiceRequest::CreateAndStart(
           profile_.get(),
-          std::set<std::string>(),
+          std::string(),
+          OAuth2TokenService::ScopeSet(),
           &consumer_));
   ui_loop_.RunUntilIdle();
   EXPECT_EQ(0, consumer_.number_of_successful_tokens_);
   EXPECT_EQ(1, consumer_.number_of_errors_);
 }
 
 TEST_F(ProfileOAuth2TokenServiceRequestTest,
        Success) {
   scoped_ptr<ProfileOAuth2TokenServiceRequest> request(
       ProfileOAuth2TokenServiceRequest::CreateAndStart(
           profile_.get(),
-          std::set<std::string>(),
+          std::string(),
+          OAuth2TokenService::ScopeSet(),
           &consumer_));
   ui_loop_.RunUntilIdle();
   EXPECT_EQ(1, consumer_.number_of_successful_tokens_);
   EXPECT_EQ("success token", consumer_.last_token_);
   EXPECT_EQ(0, consumer_.number_of_errors_);
 }
 
 TEST_F(ProfileOAuth2TokenServiceRequestTest,
        RequestDeletionBeforeServiceComplete) {
   scoped_ptr<ProfileOAuth2TokenServiceRequest> request(
       ProfileOAuth2TokenServiceRequest::CreateAndStart(
           profile_.get(),
-          std::set<std::string>(),
+          std::string(),
+          OAuth2TokenService::ScopeSet(),
           &consumer_));
   request.reset();
   ui_loop_.RunUntilIdle();
   EXPECT_EQ(0, consumer_.number_of_successful_tokens_);
   EXPECT_EQ(0, consumer_.number_of_errors_);
 }
 
 TEST_F(ProfileOAuth2TokenServiceRequestTest,
        RequestDeletionAfterServiceComplete) {
   scoped_ptr<ProfileOAuth2TokenServiceRequest> request(
       ProfileOAuth2TokenServiceRequest::CreateAndStart(
           profile_.get(),
-          std::set<std::string>(),
+          std::string(),
+          OAuth2TokenService::ScopeSet(),
           &consumer_));
   ui_loop_.RunUntilIdle();
   request.reset();
   EXPECT_EQ(1, consumer_.number_of_successful_tokens_);
   EXPECT_EQ(0, consumer_.number_of_errors_);
 }
 
 }  // namespace