Componentize GoogleURLTracker unittest

components/google/core/browser/google_url_tracker_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 "components/google/core/browser/google_url_tracker.h"
 
 #include <set>
 #include <string>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
+#include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
-#include "chrome/browser/google/google_url_tracker_factory.h"
-#include "chrome/test/base/testing_profile.h"
+#include "base/prefs/testing_pref_service.h"
 #include "components/google/core/browser/google_pref_names.h"
 #include "components/google/core/browser/google_url_tracker_client.h"
 #include "components/google/core/browser/google_url_tracker_infobar_delegate.h"
 #include "components/google/core/browser/google_url_tracker_navigation_helper.h"
 #include "components/infobars/core/infobar.h"
 #include "components/infobars/core/infobar_delegate.h"
-#include "content/public/test/test_browser_thread_bundle.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_fetcher.h"
+#include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 // TestCallbackListener ---------------------------------------------------
 
 class TestCallbackListener {
  public:
   TestCallbackListener();
   virtual ~TestCallbackListener();
@@ skipping 30 matching lines @@
   google_url_updated_subscription_ =
       google_url_tracker->RegisterCallback(base::Bind(
           &TestCallbackListener::OnGoogleURLUpdated, base::Unretained(this)));
 }
 
 
 // TestGoogleURLTrackerClient -------------------------------------------------
 
 class TestGoogleURLTrackerClient : public GoogleURLTrackerClient {
  public:
-  explicit TestGoogleURLTrackerClient(Profile* profile_);
+  explicit TestGoogleURLTrackerClient(PrefService* prefs_);
   virtual ~TestGoogleURLTrackerClient();
 
   virtual void SetListeningForNavigationStart(bool listen) OVERRIDE;
   virtual bool IsListeningForNavigationStart() OVERRIDE;
   virtual bool IsBackgroundNetworkingEnabled() OVERRIDE;
   virtual PrefService* GetPrefs() OVERRIDE;
   virtual net::URLRequestContextGetter* GetRequestContext() OVERRIDE;
 
  private:
-  Profile* profile_;
+  PrefService* prefs_;
+  scoped_refptr<net::TestURLRequestContextGetter> request_context_;
   bool observe_nav_start_;
 
   DISALLOW_COPY_AND_ASSIGN(TestGoogleURLTrackerClient);
 };
 
-TestGoogleURLTrackerClient::TestGoogleURLTrackerClient(Profile* profile)
-    : profile_(profile),
+TestGoogleURLTrackerClient::TestGoogleURLTrackerClient(PrefService* prefs)
+    : prefs_(prefs),
+      request_context_(new net::TestURLRequestContextGetter(
+          base::MessageLoopProxy::current())),
       observe_nav_start_(false) {
 }
 
 TestGoogleURLTrackerClient::~TestGoogleURLTrackerClient() {
 }
 
 void TestGoogleURLTrackerClient::SetListeningForNavigationStart(bool listen) {
   observe_nav_start_ = listen;
 }
 
 bool TestGoogleURLTrackerClient::IsListeningForNavigationStart() {
   return observe_nav_start_;
 }
 
 bool TestGoogleURLTrackerClient::IsBackgroundNetworkingEnabled() {
   return true;
 }
 
 PrefService* TestGoogleURLTrackerClient::GetPrefs() {
-  return profile_->GetPrefs();
+  return prefs_;
 }
 
 net::URLRequestContextGetter* TestGoogleURLTrackerClient::GetRequestContext() {
-  return profile_->GetRequestContext();
+  return request_context_.get();
 }
 
 
 // TestGoogleURLTrackerNavigationHelper ---------------------------------------
 
 class TestGoogleURLTrackerNavigationHelper
     : public GoogleURLTrackerNavigationHelper {
  public:
   explicit TestGoogleURLTrackerNavigationHelper(GoogleURLTracker* tracker);
   virtual ~TestGoogleURLTrackerNavigationHelper();
@@ skipping 110 matching lines @@
       infobars::InfoBarManager* infobar_manager);
   GoogleURLTrackerNavigationHelper* GetNavigationHelper(
       infobars::InfoBarManager* infobar_manager);
   void ExpectDefaultURLs() const;
   void ExpectListeningForCommit(infobars::InfoBarManager* infobar_manager,
                                 bool listening);
   bool listener_notified() const { return listener_.notified(); }
   void clear_listener_notified() { listener_.clear_notified(); }
 
  private:
-  // These are required by the TestURLFetchers GoogleURLTracker will create (see
-  // test_url_fetcher_factory.h).
-  content::TestBrowserThreadBundle thread_bundle_;
+  base::MessageLoop message_loop_;
+  TestingPrefServiceSimple prefs_;
 
   // Creating this allows us to call
   // net::NetworkChangeNotifier::NotifyObserversOfNetworkChangeForTests().
   scoped_ptr<net::NetworkChangeNotifier> network_change_notifier_;
   net::TestURLFetcherFactory fetcher_factory_;
   GoogleURLTrackerClient* client_;
-  TestingProfile profile_;
   scoped_ptr<GoogleURLTracker> google_url_tracker_;
   TestCallbackListener listener_;
   // This tracks the different "tabs" a test has "opened", so we can close them
   // properly before shutting down |google_url_tracker_|, which expects that.
   std::set<infobars::InfoBarManager*> infobar_managers_seen_;
 };
 
-GoogleURLTrackerTest::GoogleURLTrackerTest()
-    : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) {
-  GoogleURLTrackerFactory::GetInstance()->
-      RegisterUserPrefsOnBrowserContextForTest(&profile_);
+GoogleURLTrackerTest::GoogleURLTrackerTest() {
+  prefs_.registry()->RegisterStringPref(
+      prefs::kLastKnownGoogleURL,
+      GoogleURLTracker::kDefaultGoogleHomepage);
+  prefs_.registry()->RegisterStringPref(
+      prefs::kLastPromptedGoogleURL,
+      std::string());
 }
 
 GoogleURLTrackerTest::~GoogleURLTrackerTest() {
 }
 
 void GoogleURLTrackerTest::SetUp() {
   network_change_notifier_.reset(net::NetworkChangeNotifier::CreateMock());
   // Ownership is passed to google_url_tracker_, but a weak pointer is kept;
   // this is safe since GoogleURLTracker keeps the client for its lifetime.
-  client_ = new TestGoogleURLTrackerClient(&profile_);
+  client_ = new TestGoogleURLTrackerClient(&prefs_);
   scoped_ptr<GoogleURLTrackerClient> client(client_);
   google_url_tracker_.reset(new GoogleURLTracker(
       client.Pass(), GoogleURLTracker::UNIT_TEST_MODE));
 }
 
 void GoogleURLTrackerTest::TearDown() {
   while (!infobar_managers_seen_.empty())
     CloseTab(*infobar_managers_seen_.begin());
   google_url_tracker_->Shutdown();
 }
@@ skipping 29 matching lines @@
 
 void GoogleURLTrackerTest::NotifyNetworkChanged() {
   net::NetworkChangeNotifier::NotifyObserversOfNetworkChangeForTests(
       net::NetworkChangeNotifier::CONNECTION_UNKNOWN);
   // For thread safety, the NCN queues tasks to do the actual notifications, so
   // we need to spin the message loop so the tracker will actually be notified.
   base::MessageLoop::current()->RunUntilIdle();
 }
 
 void GoogleURLTrackerTest::SetLastPromptedGoogleURL(const GURL& url) {
-  profile_.GetPrefs()->SetString(prefs::kLastPromptedGoogleURL, url.spec());
+  prefs_.SetString(prefs::kLastPromptedGoogleURL, url.spec());
 }
 
 GURL GoogleURLTrackerTest::GetLastPromptedGoogleURL() {
-  return GURL(profile_.GetPrefs()->GetString(prefs::kLastPromptedGoogleURL));
+  return GURL(prefs_.GetString(prefs::kLastPromptedGoogleURL));
 }
 
 void GoogleURLTrackerTest::SetNavigationPending(
     infobars::InfoBarManager* infobar_manager,
     bool is_search) {
   if (is_search) {
     google_url_tracker_->SearchCommitted();
     // Note that the call above might not have actually registered a listener
     // for navigation starts if the searchdomaincheck response was bogus.
   }
@@ skipping 699 matching lines @@
   EXPECT_FALSE(GetInfoBarDelegate(&infobar_manager) == NULL);
   GoogleURLTrackerInfoBarDelegate* delegate2 =
       GetInfoBarDelegate(&infobar_manager2);
   ASSERT_FALSE(delegate2 == NULL);
   SetNavigationPending(&infobar_manager, true);
   ASSERT_NO_FATAL_FAILURE(ExpectListeningForCommit(&infobar_manager, true));
   delegate2->Close(false);
   SetNavigationPending(&infobar_manager, false);
   ASSERT_NO_FATAL_FAILURE(ExpectListeningForCommit(&infobar_manager, false));
 }