Componentize WebHistoryService

chrome/browser/history/web_history_service_unittest.cc

 // Copyright 2014 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/history/web_history_service.h"
+#include "components/history/core/browser/web_history_service.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "chrome/browser/history/web_history_service_factory.h"
+#include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
+#include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/sync/profile_sync_service_mock.h"
 #include "chrome/test/base/testing_profile.h"
+#include "components/signin/core/browser/profile_oauth2_token_service.h"
+#include "components/signin/core/browser/signin_manager.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "net/http/http_status_code.h"
+#include "net/url_request/url_request_context_getter.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using history::WebHistoryService;
 using ::testing::Return;
 
 namespace {
 
 // A testing web history service that does extra checks and creates a
 // TestRequest instead of a normal request.
 class TestingWebHistoryService : public WebHistoryService {
  public:
-  explicit TestingWebHistoryService(Profile* profile)
-    : WebHistoryService(profile),
-      profile_(profile),
-      expected_url_(GURL()),
-      expected_audio_history_value_(false),
-      current_expected_post_data_("") {
-  }
+  explicit TestingWebHistoryService(
+      ProfileOAuth2TokenService* token_service,
+      SigninManagerBase* signin_manager,
+      const scoped_refptr<net::URLRequestContextGetter>& request_context)
+      : WebHistoryService(token_service, signin_manager, request_context),
+        expected_url_(GURL()),
+        expected_audio_history_value_(false),
+        current_expected_post_data_("") {}
   ~TestingWebHistoryService() override {}
 
   WebHistoryService::Request* CreateRequest(
       const GURL& url, const CompletionCallback& callback) override;
 
   // This is sorta an override but override and static don't mix.
   // This function just calls WebHistoryService::ReadResponse.
   static scoped_ptr<base::DictionaryValue> ReadResponse(
       Request* request);
 
@@ skipping 17 matching lines @@
 
   void SetExpectedPostData(const std::string& expected_data) {
     current_expected_post_data_= expected_data;
   }
 
   void EnsureNoPendingRequestsRemain() {
     EXPECT_EQ(0u, GetNumberOfPendingAudioHistoryRequests());
   }
 
  private:
-  Profile* profile_;
   GURL expected_url_;
   bool expected_audio_history_value_;
   std::string current_expected_post_data_;
   std::map<Request*, std::string> expected_post_data_;
 
   DISALLOW_COPY_AND_ASSIGN(TestingWebHistoryService);
 };
 
 // A testing request class that allows expected values to be filled in.
 class TestRequest : public WebHistoryService::Request {
  public:
-  TestRequest(Profile* profile,
-              const GURL& url,
+  TestRequest(const GURL& url,
               const WebHistoryService::CompletionCallback& callback,
               int response_code,
               const std::string& response_body)
-      : profile_(profile),
-        web_history_service_(nullptr),
+      : web_history_service_(nullptr),
         url_(url),
         callback_(callback),
         response_code_(response_code),
         response_body_(response_body),
         post_data_(""),
         is_pending_(false) {
   }
 
-  TestRequest(Profile* profile,
-              const GURL& url,
+  TestRequest(const GURL& url,
               const WebHistoryService::CompletionCallback& callback,
               TestingWebHistoryService* web_history_service)
-      : profile_(profile),
-        web_history_service_(web_history_service),
+      : web_history_service_(web_history_service),
         url_(url),
         callback_(callback),
         response_code_(net::HTTP_OK),
         response_body_(""),
         post_data_(""),
         is_pending_(false) {
     response_body_ = std::string("{\"history_recording_enabled\":") +
                      web_history_service->GetExpectedAudioHistoryValue() +
                      ("}");
   }
@@ skipping 16 matching lines @@
   }
 
   void MimicReturnFromFetch() {
     // Mimic a successful fetch and return. We don't actually send out a request
     // in unittests.
     EXPECT_EQ(web_history_service_->GetExpectedPostData(this), post_data_);
     callback_.Run(this, true);
   }
 
  private:
-  Profile* profile_;
   TestingWebHistoryService* web_history_service_;
   GURL url_;
   WebHistoryService::CompletionCallback callback_;
   int response_code_;
   std::string response_body_;
   std::string post_data_;
   bool is_pending_;
 
   DISALLOW_COPY_AND_ASSIGN(TestRequest);
 };
 
 WebHistoryService::Request* TestingWebHistoryService::CreateRequest(
     const GURL& url, const CompletionCallback& callback) {
   EXPECT_EQ(expected_url_, url);
   WebHistoryService::Request* request =
-      new TestRequest(profile_, url, callback, this);
+      new TestRequest(url, callback, this);
   expected_post_data_[request] = current_expected_post_data_;
   return request;
 }
 
 scoped_ptr<base::DictionaryValue> TestingWebHistoryService::ReadResponse(
     Request* request) {
   return WebHistoryService::ReadResponse(request);
 }
 
 void TestingWebHistoryService::SetAudioHistoryCallback(
@@ skipping 20 matching lines @@
     Request* request) {
   return expected_post_data_[request];
 }
 
 std::string TestingWebHistoryService::GetExpectedAudioHistoryValue() {
   if (expected_audio_history_value_)
     return "true";
   return "false";
 }
 
-static KeyedService* BuildWebHistoryService(content::BrowserContext* profile) {
-  return new TestingWebHistoryService(static_cast<Profile*>(profile));
+static KeyedService* BuildWebHistoryService(content::BrowserContext* context) {
+  Profile* profile = static_cast<Profile*>(context);

[droger, 2015/01/28 11:03:15]

You can use Profile::FromBrowserContext() here instead.

+  return new TestingWebHistoryService(
+      ProfileOAuth2TokenServiceFactory::GetForProfile(profile),
+      SigninManagerFactory::GetForProfile(profile),
+      profile->GetRequestContext());
 }
 
 }  // namespace
 
 // A test class used for testing the WebHistoryService class.
 // In order for WebHistoryService to be valid, we must have a valid
 // ProfileSyncService. Using the ProfileSyncServiceMock class allows to
 // assign specific return values as needed to make sure the web history
 // service is available.
 class WebHistoryServiceTest : public testing::Test {
@@ skipping 127 matching lines @@
     base::Bind(&TestingWebHistoryService::EnsureNoPendingRequestsRemain,
     base::Unretained(web_history_service)));
 }
 
 TEST_F(WebHistoryServiceTest, VerifyReadResponse) {
   // Test that properly formatted response with good response code returns true
   // as expected.
   WebHistoryService::CompletionCallback completion_callback;
   scoped_ptr<WebHistoryService::Request> request(
       new TestRequest(
-          profile(),
           GURL("http://history.google.com/"),
           completion_callback,
           net::HTTP_OK, /* response code */
           "{\n" /* response body */
           "  \"history_recording_enabled\": true\n"
           "}"));
   scoped_ptr<base::DictionaryValue> response_value;
   // ReadResponse deletes the request
   response_value = TestingWebHistoryService::ReadResponse(request.get());
   bool enabled_value = false;
   response_value->GetBoolean("history_recording_enabled", &enabled_value);
   EXPECT_TRUE(enabled_value);
 
   // Test that properly formatted response with good response code returns false
   // as expected.
   scoped_ptr<WebHistoryService::Request> request2(
       new TestRequest(
-          profile(),
           GURL("http://history.google.com/"),
           completion_callback,
           net::HTTP_OK,
           "{\n"
           "  \"history_recording_enabled\": false\n"
           "}"));
   scoped_ptr<base::DictionaryValue> response_value2;
   // ReadResponse deletes the request
   response_value2 = TestingWebHistoryService::ReadResponse(request2.get());
   enabled_value = true;
   response_value2->GetBoolean("history_recording_enabled", &enabled_value);
   EXPECT_FALSE(enabled_value);
 
   // Test that a bad response code returns false.
   scoped_ptr<WebHistoryService::Request> request3(
       new TestRequest(
-          profile(),
           GURL("http://history.google.com/"),
           completion_callback,
           net::HTTP_UNAUTHORIZED,
           "{\n"
           "  \"history_recording_enabled\": true\n"
           "}"));
   scoped_ptr<base::DictionaryValue> response_value3;
   // ReadResponse deletes the request
   response_value3 = TestingWebHistoryService::ReadResponse(request3.get());
   EXPECT_FALSE(response_value3);
 
   // Test that improperly formatted response returns false.
   // Note: we expect to see a warning when running this test similar to
   //   "Non-JSON response received from history server".
   // This test tests how that situation is handled.
   scoped_ptr<WebHistoryService::Request> request4(
       new TestRequest(
-          profile(),
           GURL("http://history.google.com/"),
           completion_callback,
           net::HTTP_OK,
           "{\n"
           "  \"history_recording_enabled\": not true\n"
           "}"));
   scoped_ptr<base::DictionaryValue> response_value4;
   // ReadResponse deletes the request
   response_value4 = TestingWebHistoryService::ReadResponse(request4.get());
   EXPECT_FALSE(response_value4);
 
   // Test that improperly formatted response returns false.
   scoped_ptr<WebHistoryService::Request> request5(
       new TestRequest(
-          profile(),
           GURL("http://history.google.com/"),
           completion_callback,
           net::HTTP_OK,
           "{\n"
           "  \"history_recording\": true\n"
           "}"));
   scoped_ptr<base::DictionaryValue> response_value5;
   // ReadResponse deletes the request
   response_value5 = TestingWebHistoryService::ReadResponse(request5.get());
   enabled_value = true;
   EXPECT_FALSE(response_value5->GetBoolean("history_recording_enabled",
                                            &enabled_value));
   EXPECT_TRUE(enabled_value);
 }