Move FakeWebHistoryService to components/history

chrome/browser/browsing_data/history_counter_browsertest.cc

 // Copyright (c) 2015 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/browsing_data/history_counter.h"
 
 #include "base/prefs/pref_service.h"
 #include "base/run_loop.h"
-#include "base/strings/string_number_conversions.h"
 #include "chrome/browser/history/history_service_factory.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/test/integration/sync_test.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/pref_names.h"
 #include "components/browser_sync/browser/profile_sync_service.h"
+#include "components/history/core/browser/fake_web_history_service.h"
 #include "components/history/core/browser/history_service.h"
 #include "components/history/core/browser/web_history_service.h"
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
 #include "components/signin/core/browser/signin_manager.h"
-#include "net/base/url_util.h"
 #include "net/http/http_status_code.h"
 #include "url/gurl.h"
 
 namespace {
 
 class HistoryCounterTest : public SyncTest {
  public:
   HistoryCounterTest() : SyncTest(SINGLE_CLIENT) {
     // TODO(msramek): Only one of the test cases, RestartOnSyncChange, is a Sync
     // integration test. Extract it and move it to the rest of integration tests
@@ skipping 196 matching lines @@
 
   SetDeletionPeriodPref(BrowsingDataRemover::FOUR_WEEKS);
   WaitForCounting();
   EXPECT_EQ(8u, GetLocalResult());
 
   SetDeletionPeriodPref(BrowsingDataRemover::EVERYTHING);
   WaitForCounting();
   EXPECT_EQ(9u, GetLocalResult());
 }
 
-class FakeWebHistoryService : public history::WebHistoryService {
- public:
-
-  class Request : public history::WebHistoryService::Request {
-   public:
-    Request(FakeWebHistoryService* service,
-            bool emulate_success,
-            int emulate_response_code,
-            const CompletionCallback& callback,
-            base::Time begin,
-            base::Time end)
-        : service_(service),
-          emulate_success_(emulate_success),
-          emulate_response_code_(emulate_response_code),
-          callback_(callback),
-          begin_(begin),
-          end_(end),
-          is_pending_(false) {
-    }
-
-    bool IsPending() override {
-      return is_pending_;
-    }
-
-    int GetResponseCode() override {
-      return emulate_response_code_;
-    }
-
-    const std::string& GetResponseBody() override {
-      // It is currently not important to mimic the exact format of visits,
-      // just to get the correct number.
-      response_body_ = "{ \"event\": [";
-      for (int i = 0;
-           i < service_->GetNumberOfVisitsBetween(begin_, end_); ++i) {
-        response_body_ += i ? ", {}" : "{}";
-      }
-      response_body_ += "] }";
-      return response_body_;
-    }
-
-    void SetPostData(const std::string& post_data) override {};
-
-    void Start() override {
-      is_pending_ = true;
-      callback_.Run(this, emulate_success_);
-    }
-
-   private:
-    FakeWebHistoryService* service_;
-    bool emulate_success_;
-    int emulate_response_code_;
-    const CompletionCallback& callback_;
-    base::Time begin_;
-    base::Time end_;
-    bool is_pending_;
-    std::string response_body_;
-
-    DISALLOW_COPY_AND_ASSIGN(Request);
-  };
-
-  explicit FakeWebHistoryService(Profile* profile)
-      : history::WebHistoryService(
-            ProfileOAuth2TokenServiceFactory::GetForProfile(profile),
-            SigninManagerFactory::GetForProfile(profile),
-            profile->GetRequestContext()) {
-  }
-
-  void SetRequestOptions(bool emulate_success, int emulate_response_code) {
-    emulate_success_ = emulate_success;
-    emulate_response_code_ = emulate_response_code;
-  }
-
-  void AddSyncedVisit(std::string url, base::Time timestamp) {
-    visits_.push_back(make_pair(url, timestamp));
-  }
-
-  void ClearSyncedVisits() {
-    visits_.clear();
-  }
-
-  int GetNumberOfVisitsBetween(const base::Time& begin, const base::Time& end) {
-    int result = 0;
-    for (const Visit& visit : visits_) {
-      if (visit.second >= begin && visit.second < end)
-        ++result;
-    }
-    return result;
-  }
-
- private:
-  base::Time GetTimeForKeyInQuery(
-      const GURL& url, const std::string& key) {
-    std::string value;
-    if (!net::GetValueForKeyInQuery(url, key, &value))
-      return base::Time();
-
-    int64 us;
-    if (!base::StringToInt64(value, &us))
-      return base::Time();
-    return base::Time::UnixEpoch() + base::TimeDelta::FromMicroseconds(us);
-  }
-
-  Request* CreateRequest(const GURL& url,
-                         const CompletionCallback& callback) override {
-    // Find the time range endpoints in the URL.
-    base::Time begin = GetTimeForKeyInQuery(url, "min");
-    base::Time end = GetTimeForKeyInQuery(url, "max");
-
-    if (end.is_null())
-      end = base::Time::Max();
-
-    return new Request(
-        this, emulate_success_, emulate_response_code_, callback, begin, end);
-  }
-
-  // Parameters for the fake request.
-  bool emulate_success_;
-  int emulate_response_code_;
-
-  // Fake visits storage.
-  typedef std::pair<std::string, base::Time> Visit;
-  std::vector<Visit> visits_;
-
-  DISALLOW_COPY_AND_ASSIGN(FakeWebHistoryService);
-};
-
 // Test the behavior for a profile that syncs history.
 IN_PROC_BROWSER_TEST_F(HistoryCounterTest, Synced) {
   // WebHistoryService makes network requests, so we need to use a fake one
   // for testing.
-  // TODO(msramek): Move this to a separate file, next to WebHistoryService.
-  scoped_ptr<FakeWebHistoryService> service(
-      new FakeWebHistoryService(browser()->profile()));
+  scoped_ptr<history::FakeWebHistoryService> service(
+      new history::FakeWebHistoryService(
+          ProfileOAuth2TokenServiceFactory::GetForProfile(browser()->profile()),
+          SigninManagerFactory::GetForProfile(browser()->profile()),
+          browser()->profile()->GetRequestContext()));
 
   HistoryCounter counter;
   counter.SetWebHistoryServiceForTesting(service.get());
   counter.Init(browser()->profile(),
                base::Bind(&HistoryCounterTest::Callback,
                           base::Unretained(this)));
 
   // No entries locally and no entries in Sync.
-  service->SetRequestOptions(true /* success */, net::HTTP_OK);
+  service->SetupFakeResponse(true /* success */, net::HTTP_OK);
   counter.Restart();
   WaitForCounting();
   EXPECT_EQ(0u, GetLocalResult());
   EXPECT_FALSE(HasSyncedVisits());
 
   // No entries locally. There are some entries in Sync, but they are out of the
   // time range.
   SetDeletionPeriodPref(BrowsingDataRemover::LAST_HOUR);
   service->AddSyncedVisit(
       "www.google.com", GetCurrentTime() - base::TimeDelta::FromHours(2));
   service->AddSyncedVisit(
       "www.chrome.com", GetCurrentTime() - base::TimeDelta::FromHours(2));
-  service->SetRequestOptions(true /* success */, net::HTTP_OK);
+  service->SetupFakeResponse(true /* success */, net::HTTP_OK);
   counter.Restart();
   WaitForCounting();
   EXPECT_EQ(0u, GetLocalResult());
   EXPECT_FALSE(HasSyncedVisits());
 
   // No entries locally, but some entries in Sync.
   service->AddSyncedVisit("www.google.com", GetCurrentTime());
-  service->SetRequestOptions(true /* success */, net::HTTP_OK);
+  service->SetupFakeResponse(true /* success */, net::HTTP_OK);
   counter.Restart();
   WaitForCounting();
   EXPECT_EQ(0u, GetLocalResult());
   EXPECT_TRUE(HasSyncedVisits());
 
   // To err on the safe side, if the server request fails, we assume that there
   // might be some items on the server.
-  service->SetRequestOptions(true /* success */,
+  service->SetupFakeResponse(true /* success */,
                              net::HTTP_INTERNAL_SERVER_ERROR);
   counter.Restart();
   WaitForCounting();
   EXPECT_EQ(0u, GetLocalResult());
   EXPECT_TRUE(HasSyncedVisits());
 
   // Same when the entire query fails.
-  service->SetRequestOptions(false /* success */,
+  service->SetupFakeResponse(false /* success */,
                              net::HTTP_INTERNAL_SERVER_ERROR);
   counter.Restart();
   WaitForCounting();
   EXPECT_EQ(0u, GetLocalResult());
   EXPECT_TRUE(HasSyncedVisits());
 
   // Nonzero local count, nonempty sync.
   AddVisit("https://www.google.com");
   AddVisit("https://www.chrome.com");
-  service->SetRequestOptions(true /* success */, net::HTTP_OK);
+  service->SetupFakeResponse(true /* success */, net::HTTP_OK);
   counter.Restart();
   WaitForCounting();
   EXPECT_EQ(2u, GetLocalResult());
   EXPECT_TRUE(HasSyncedVisits());
 
   // Nonzero local count, empty sync.
   service->ClearSyncedVisits();
-  service->SetRequestOptions(true /* success */, net::HTTP_OK);
+  service->SetupFakeResponse(true /* success */, net::HTTP_OK);
   counter.Restart();
   WaitForCounting();
   EXPECT_EQ(2u, GetLocalResult());
   EXPECT_FALSE(HasSyncedVisits());
 }
 
 // Test that the counting restarts when history sync state changes.
 // TODO(crbug.com/553421): Enable this test and move it to the
 // sync/test/integration directory.
 IN_PROC_BROWSER_TEST_F(HistoryCounterTest, DISABLED_RestartOnSyncChange) {
   // Set up the Sync client.
   ASSERT_TRUE(SetupClients());
   static const int kFirstProfileIndex = 0;
   ProfileSyncService* sync_service = GetSyncService(kFirstProfileIndex);
   Profile* profile = GetProfile(kFirstProfileIndex);
 
   // Set up the fake web history service and the counter.
-  scoped_ptr<FakeWebHistoryService> web_history_service(
-      new FakeWebHistoryService(profile));
+  scoped_ptr<history::FakeWebHistoryService> web_history_service(
+      new history::FakeWebHistoryService(
+          ProfileOAuth2TokenServiceFactory::GetForProfile(browser()->profile()),
+          SigninManagerFactory::GetForProfile(browser()->profile()),
+          browser()->profile()->GetRequestContext()));
   HistoryCounter counter;
   counter.SetWebHistoryServiceForTesting(web_history_service.get());
   counter.Init(profile,
                base::Bind(&HistoryCounterTest::Callback,
                           base::Unretained(this)));
 
   // Note that some Sync operations notify observers immediately (and thus there
   // is no need to call |WaitForCounting()|; in fact, it would block the test),
   // while other operations only post the task on UI thread's message loop
   // (which requires calling |WaitForCounting()| for them to run). Therefore,
@@ skipping 45 matching lines @@
   // history deletion did not change. However, in reality we can get two
   // notifications, one that history sync has stopped and another that it is
   // active again.
 
   // Stopping the Sync service triggers a restart.
   sync_service->RequestStop(sync_driver::SyncService::CLEAR_DATA);
   WaitForCountingOrConfirmFinished();
 }
 
 }  // namespace