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

chrome/browser/local_discovery/privet_confirm_api_flow_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/message_loop/message_loop.h"
 #include "chrome/browser/local_discovery/privet_confirm_api_flow.h"
+#include "chrome/browser/signin/fake_profile_oauth2_token_service.h"
 #include "content/public/test/test_browser_thread.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_request_headers.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 14 matching lines @@
 const char kFailedConfirmResponseBadJson[] = "["
     "   \"success\""
     "]";
 
 class TestOAuth2TokenService : public OAuth2TokenService {
  public:
   explicit TestOAuth2TokenService(net::URLRequestContextGetter* request_context)
       : request_context_(request_context) {
   }
  protected:
-  virtual std::string GetRefreshToken() OVERRIDE {
+  virtual std::string GetRefreshToken(const std::string& account_id) OVERRIDE {
     return "SampleToken";
   }
 
   virtual net::URLRequestContextGetter* GetRequestContext() OVERRIDE {
     return request_context_.get();
   }
 
  private:
   scoped_refptr<net::URLRequestContextGetter> request_context_;
 };
@@ skipping 27 matching lines @@
   content::TestBrowserThread ui_thread_;
   scoped_refptr<net::TestURLRequestContextGetter> request_context_;
   net::TestURLFetcherFactory fetcher_factory_;
   TestOAuth2TokenService token_service_;
   MockableConfirmCallback callback_;
 };
 
 TEST_F(PrivetConfirmApiFlowTest, SuccessOAuth2) {
   PrivetConfirmApiCallFlow confirm_flow(request_context_.get(),
                                         &token_service_,
+                                        std::string(),

[Andrew T Wilson (Slow), 2013/09/03 14:04:24]

This is fine - I just wonder if perhaps we want to prevent ever passing in an
empty account ID to OAuth2TokenService, so we should codify that with a DCHECK()
and make tests pass in a non-empty test acct ID. Your call - just wanted to
suggest it.

[fgorski, 2013/09/03 20:50:40]

Done. I agree with you. Roger mentioned a potential DCHECK earlier I just never
got down to revisiting all of the calls. Given that GetRefreshToken is simply
returning tokens here, I am using a dummy account_id.

                                         GURL("http://SoMeUrL.com"),
                                         callback_.callback());
 
   confirm_flow.Start();
 
   confirm_flow.OnGetTokenSuccess(NULL, "SomeToken", base::Time());
   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
 
   EXPECT_EQ(GURL("http://SoMeUrL.com"), fetcher->GetOriginalURL());
 
@@ skipping 42 matching lines @@
   fetcher->set_response_code(200);
 
   EXPECT_CALL(callback_, ConfirmCallback(PrivetConfirmApiCallFlow::SUCCESS));
 
   fetcher->delegate()->OnURLFetchComplete(fetcher);
 }
 
 TEST_F(PrivetConfirmApiFlowTest, BadToken) {
   PrivetConfirmApiCallFlow confirm_flow(request_context_.get(),
                                         &token_service_,
+                                        std::string(),
                                         GURL("http://SoMeUrL.com"),
                                         callback_.callback());
 
   confirm_flow.Start();
 
   EXPECT_CALL(callback_,
               ConfirmCallback(PrivetConfirmApiCallFlow::ERROR_TOKEN));
   confirm_flow.OnGetTokenFailure(NULL, GoogleServiceAuthError(
       GoogleServiceAuthError::USER_NOT_SIGNED_UP));
 }
 
 TEST_F(PrivetConfirmApiFlowTest, ServerFailure) {
   PrivetConfirmApiCallFlow confirm_flow(request_context_.get(),
                                         &token_service_,
+                                        std::string(),
                                         GURL("http://SoMeUrL.com"),
                                         callback_.callback());
 
   confirm_flow.Start();
 
   confirm_flow.OnGetTokenSuccess(NULL, "SomeToken", base::Time());
   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
 
   EXPECT_EQ(GURL("http://SoMeUrL.com"), fetcher->GetOriginalURL());
 
   fetcher->SetResponseString(kFailedConfirmResponse);
   fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::SUCCESS,
                                             net::OK));
   fetcher->set_response_code(200);
 
   EXPECT_CALL(callback_,
               ConfirmCallback(PrivetConfirmApiCallFlow::ERROR_FROM_SERVER));
 
   fetcher->delegate()->OnURLFetchComplete(fetcher);
 }
 
 TEST_F(PrivetConfirmApiFlowTest, BadJson) {
   PrivetConfirmApiCallFlow confirm_flow(request_context_.get(),
                                         &token_service_,
+                                        std::string(),
                                         GURL("http://SoMeUrL.com"),
                                         callback_.callback());
 
   confirm_flow.Start();
 
   confirm_flow.OnGetTokenSuccess(NULL, "SomeToken", base::Time());
   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
 
   EXPECT_EQ(GURL("http://SoMeUrL.com"), fetcher->GetOriginalURL());
 
   fetcher->SetResponseString(kFailedConfirmResponseBadJson);
   fetcher->set_status(net::URLRequestStatus(
       net::URLRequestStatus::SUCCESS,
       net::OK));
   fetcher->set_response_code(200);
 
   EXPECT_CALL(callback_, ConfirmCallback
               (PrivetConfirmApiCallFlow::ERROR_MALFORMED_RESPONSE));
 
   fetcher->delegate()->OnURLFetchComplete(fetcher);
 }
 
 }  // namespace
 
 }  // namespace local_discovery