Refactor ProfileOAuth2TokenServiceRequest into OAuth2TokenServiceRequest

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/fake_profile_oauth2_token_service.h"
@@ skipping 50 matching lines @@
     const OAuth2TokenService::Request* request,
     const GoogleServiceAuthError& error) {
   last_error_ = error;
   ++number_of_errors_;
 }
 
 class ProfileOAuth2TokenServiceRequestTest : public testing::Test {
  public:
   virtual void SetUp() OVERRIDE;
 
+  virtual void TearDown() OVERRIDE;
+
  protected:
   base::MessageLoop ui_loop_;
   scoped_ptr<content::TestBrowserThread> ui_thread_;
 
   scoped_ptr<Profile> profile_;
   TestingOAuth2TokenServiceConsumer consumer_;
   FakeProfileOAuth2TokenService* oauth2_service_;
 
   scoped_ptr<ProfileOAuth2TokenServiceRequest> request_;
 };
 
 void ProfileOAuth2TokenServiceRequestTest::SetUp() {
   ui_thread_.reset(new content::TestBrowserThread(content::BrowserThread::UI,
                                                   &ui_loop_));
   TestingProfile::Builder builder;
   builder.AddTestingFactory(ProfileOAuth2TokenServiceFactory::GetInstance(),
                             &BuildFakeProfileOAuth2TokenService);
   profile_ = builder.Build();
 
   oauth2_service_ = (FakeProfileOAuth2TokenService*)
       ProfileOAuth2TokenServiceFactory::GetForProfile(profile_.get());
 }
 
+void ProfileOAuth2TokenServiceRequestTest::TearDown() {
+  // Destroy the request and run the message loop one last time to ensure that
+  // resources that must be destroyed in the UI thread get cleaned up.
+  request_.reset();
+  ui_loop_.RunUntilIdle();
+}
+
 TEST_F(ProfileOAuth2TokenServiceRequestTest,
        Failure) {
   scoped_ptr<ProfileOAuth2TokenServiceRequest> request(
       ProfileOAuth2TokenServiceRequest::CreateAndStart(
           profile_.get(),
-          std::string(),
+          kAccountId,
           OAuth2TokenService::ScopeSet(),
           &consumer_));
+  // Run to ensure the request has been made.
+  ui_loop_.RunUntilIdle();
   oauth2_service_->IssueErrorForAllPendingRequests(
       GoogleServiceAuthError(GoogleServiceAuthError::SERVICE_UNAVAILABLE));
   ui_loop_.RunUntilIdle();
   EXPECT_EQ(0, consumer_.number_of_successful_tokens_);
   EXPECT_EQ(1, consumer_.number_of_errors_);
 }
 
 TEST_F(ProfileOAuth2TokenServiceRequestTest, Success) {
   oauth2_service_->UpdateCredentials(kAccountId, kRefreshToken);
   scoped_ptr<ProfileOAuth2TokenServiceRequest> request(
       ProfileOAuth2TokenServiceRequest::CreateAndStart(
           profile_.get(),
           kAccountId,
           OAuth2TokenService::ScopeSet(),
           &consumer_));
+  // Run to ensure the request has been made.
+  ui_loop_.RunUntilIdle();
   oauth2_service_->IssueTokenForAllPendingRequests(kAccessToken,
                                                    base::Time::Max());
   ui_loop_.RunUntilIdle();
   EXPECT_EQ(1, consumer_.number_of_successful_tokens_);
   EXPECT_EQ(kAccessToken, consumer_.last_token_);
   EXPECT_EQ(0, consumer_.number_of_errors_);
 }
 
 TEST_F(ProfileOAuth2TokenServiceRequestTest,
        RequestDeletionBeforeServiceComplete) {
   oauth2_service_->UpdateCredentials(kAccountId, kRefreshToken);
   scoped_ptr<ProfileOAuth2TokenServiceRequest> request(
       ProfileOAuth2TokenServiceRequest::CreateAndStart(
           profile_.get(),
           kAccountId,
           OAuth2TokenService::ScopeSet(),
           &consumer_));
+  // Run to ensure the request has been made.
+  ui_loop_.RunUntilIdle();
   request.reset();
   oauth2_service_->IssueTokenForAllPendingRequests(kAccessToken,
                                                    base::Time::Max());
   ui_loop_.RunUntilIdle();
   EXPECT_EQ(0, consumer_.number_of_successful_tokens_);
   EXPECT_EQ(0, consumer_.number_of_errors_);
 }
 
 TEST_F(ProfileOAuth2TokenServiceRequestTest,
        RequestDeletionAfterServiceComplete) {
   oauth2_service_->UpdateCredentials(kAccountId, kRefreshToken);
   scoped_ptr<ProfileOAuth2TokenServiceRequest> request(
       ProfileOAuth2TokenServiceRequest::CreateAndStart(
           profile_.get(),
           kAccountId,
           OAuth2TokenService::ScopeSet(),
           &consumer_));
+  // Run to ensure the request has been made.
+  ui_loop_.RunUntilIdle();
   oauth2_service_->IssueTokenForAllPendingRequests(kAccessToken,
                                                    base::Time::Max());
   ui_loop_.RunUntilIdle();
   request.reset();
   EXPECT_EQ(1, consumer_.number_of_successful_tokens_);
   EXPECT_EQ(0, consumer_.number_of_errors_);
 }
 
 }  // namespace