GTTF: Use a fresh TestingBrowserProcess for each test, part #1

chrome/browser/autocomplete/autocomplete_unittest.cc

 // Copyright (c) 2011 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/message_loop.h"
 #include "base/scoped_ptr.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/autocomplete/autocomplete.h"
 #include "chrome/browser/autocomplete/autocomplete_match.h"
 #include "chrome/browser/autocomplete/keyword_provider.h"
 #include "chrome/browser/autocomplete/search_provider.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/search_engines/template_url_model.h"
 #include "chrome/common/notification_observer.h"
 #include "chrome/common/notification_registrar.h"
 #include "chrome/common/notification_service.h"
+#include "chrome/test/testing_browser_process.h"
+#include "chrome/test/testing_browser_process_test.h"
 #include "chrome/test/testing_profile.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 static std::ostream& operator<<(std::ostream& os,
                                 const AutocompleteResult::const_iterator& it) {
   return os << static_cast<const AutocompleteMatch*>(&(*it));
 }
 
 namespace {
 
@@ skipping 87 matching lines @@
   ACProviders providers_;
 
   AutocompleteResult result_;
 
  private:
   // NotificationObserver
   virtual void Observe(NotificationType type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
+  ScopedTestingBrowserProcess browser_process_;
+
   MessageLoopForUI message_loop_;
   scoped_ptr<AutocompleteController> controller_;
   NotificationRegistrar registrar_;
   TestingProfile profile_;
 };
 
 void AutocompleteProviderTest::ResetControllerWithTestProviders(
     bool same_destinations) {
   // Forget about any existing providers.  The controller owns them and will
   // Release() them below, when we delete it during the call to reset().
@@ skipping 118 matching lines @@
        i != result_.end(); ++i)
     EXPECT_EQ(providers_[1], i->provider);
 }
 
 TEST_F(AutocompleteProviderTest, AllowExactKeywordMatch) {
   ResetControllerWithTestProvidersWithKeywordAndSearchProviders();
   RunExactKeymatchTest(true);
   RunExactKeymatchTest(false);
 }
 
-TEST(AutocompleteTest, InputType) {
+typedef TestingBrowserProcessTest AutocompleteTest;
+
+TEST_F(AutocompleteTest, InputType) {
   struct test_data {
     const string16 input;
     const AutocompleteInput::Type type;
   } input_cases[] = {
     { ASCIIToUTF16(""), AutocompleteInput::INVALID },
     { ASCIIToUTF16("?"), AutocompleteInput::FORCED_QUERY },
     { ASCIIToUTF16("?foo"), AutocompleteInput::FORCED_QUERY },
     { ASCIIToUTF16("?foo bar"), AutocompleteInput::FORCED_QUERY },
     { ASCIIToUTF16("?http://foo.com/bar"), AutocompleteInput::FORCED_QUERY },
     { ASCIIToUTF16("foo"), AutocompleteInput::UNKNOWN },
@@ skipping 76 matching lines @@
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(input_cases); ++i) {
     SCOPED_TRACE(input_cases[i].input);
     AutocompleteInput input(input_cases[i].input, string16(), true, false,
                             true, false);
     EXPECT_EQ(input_cases[i].type, input.type());
   }
 }
 
-TEST(AutocompleteTest, InputTypeWithDesiredTLD) {
+TEST_F(AutocompleteTest, InputTypeWithDesiredTLD) {
   struct test_data {
     const string16 input;
     const AutocompleteInput::Type type;
   } input_cases[] = {
     { ASCIIToUTF16("401k"), AutocompleteInput::REQUESTED_URL },
     { ASCIIToUTF16("999999999999999"), AutocompleteInput::REQUESTED_URL },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(input_cases); ++i) {
     AutocompleteInput input(input_cases[i].input, ASCIIToUTF16("com"), true,
                             false, true, false);
     EXPECT_EQ(input_cases[i].type, input.type()) << "Input: " <<
         input_cases[i].input;
   }
 }
 
 // This tests for a regression where certain input in the omnibox caused us to
 // crash. As long as the test completes without crashing, we're fine.
-TEST(AutocompleteTest, InputCrash) {
+TEST_F(AutocompleteTest, InputCrash) {
   AutocompleteInput input(WideToUTF16(L"\uff65@s"), string16(), true, false,
                           true, false);
 }
 
 // Test comparing matches relevance.
 TEST(AutocompleteMatch, MoreRelevant) {
   struct RelevantCases {
     int r1;
     int r2;
     bool expected_result;
@@ skipping 42 matching lines @@
         Component(12, 11) },
     { ASCIIToUTF16("view-source:"), Component(0, 11), kInvalidComponent },
     { ASCIIToUTF16("view-source:garbage"), kInvalidComponent,
         Component(12, 7) },
     { ASCIIToUTF16("view-source:http://http://foo"), Component(12, 4),
         Component(19, 4) },
     { ASCIIToUTF16("view-source:view-source:http://example.com/"),
         Component(12, 11), kInvalidComponent }
   };
 
+  ScopedTestingBrowserProcess browser_process;
+
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(input_cases); ++i) {
     Component scheme, host;
     AutocompleteInput::ParseForEmphasizeComponents(input_cases[i].input,
                                                    string16(),
                                                    &scheme,
                                                    &host);
     AutocompleteInput input(input_cases[i].input, string16(), true, false,
                             true, false);
     EXPECT_EQ(input_cases[i].scheme.begin, scheme.begin) << "Input: " <<
         input_cases[i].input;
     EXPECT_EQ(input_cases[i].scheme.len, scheme.len) << "Input: " <<
         input_cases[i].input;
     EXPECT_EQ(input_cases[i].host.begin, host.begin) << "Input: " <<
         input_cases[i].input;
     EXPECT_EQ(input_cases[i].host.len, host.len) << "Input: " <<
         input_cases[i].input;
   }
 }
 
 }  // namespace