Update chrome/ to use scoped_refptr<T>::get() rather than implicit "operator T*"

chrome/browser/autocomplete/search_provider_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/autocomplete/search_provider.h"
 
 #include "base/metrics/field_trial.h"
 #include "base/prefs/pref_service.h"
 #include "base/run_loop.h"
 #include "base/string_util.h"
@@ skipping 1911 matching lines @@
                              "?http://www.abc.com", 14 },
     { "?www.ab",              "http://www.abc.com",
                                     "?www.abc.com", 7 },
     { "?ab",                  "http://www.abc.com",
                                     "?www.abc.com", 7 },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); i++) {
     QueryForInput(ASCIIToUTF16(cases[i].input), false, false);
     SearchProvider::NavigationResult result(
-        *provider_, GURL(cases[i].url), string16(), false, 0);
+        *provider_.get(), GURL(cases[i].url), string16(), false, 0);
     AutocompleteMatch match(provider_->NavigationToMatch(result));
     EXPECT_EQ(cases[i].inline_offset, match.inline_autocomplete_offset);
     EXPECT_EQ(ASCIIToUTF16(cases[i].fill_into_edit), match.fill_into_edit);
   }
 }
 
 // Verifies that "http://" is not trimmed for input that is a leading substring.
 TEST_F(SearchProviderTest, NavigationInlineSchemeSubstring) {
   const string16 input(ASCIIToUTF16("ht"));
   const string16 url(ASCIIToUTF16("http://a.com"));
   const SearchProvider::NavigationResult result(
-      *provider_, GURL(url), string16(), false, 0);
+      *provider_.get(), GURL(url), string16(), false, 0);
 
   // Check the offset and strings when inline autocompletion is allowed.
   QueryForInput(input, false, false);
   AutocompleteMatch match_inline(provider_->NavigationToMatch(result));
   EXPECT_EQ(2U, match_inline.inline_autocomplete_offset);
   EXPECT_EQ(url, match_inline.fill_into_edit);
   EXPECT_EQ(url, match_inline.contents);
 
   // Check the same offset and strings when inline autocompletion is prevented.
   QueryForInput(input, true, false);
   AutocompleteMatch match_prevent(provider_->NavigationToMatch(result));
   EXPECT_EQ(string16::npos, match_prevent.inline_autocomplete_offset);
   EXPECT_EQ(url, match_prevent.fill_into_edit);
   EXPECT_EQ(url, match_prevent.contents);
 }
 
 // Verifies that input "w" marks a more significant domain label than "www.".
 TEST_F(SearchProviderTest, NavigationInlineDomainClassify) {
   QueryForInput(ASCIIToUTF16("w"), false, false);
   const GURL url("http://www.wow.com");
   const SearchProvider::NavigationResult result(
-      *provider_, url, string16(), false, 0);
+      *provider_.get(), url, string16(), false, 0);
   AutocompleteMatch match(provider_->NavigationToMatch(result));
   EXPECT_EQ(5U, match.inline_autocomplete_offset);
   EXPECT_EQ(ASCIIToUTF16("www.wow.com"), match.fill_into_edit);
   EXPECT_EQ(ASCIIToUTF16("www.wow.com"), match.contents);
 
   // Ensure that the match for input "w" is marked on "wow" and not "www".
   ASSERT_EQ(3U, match.contents_class.size());
   EXPECT_EQ(0U, match.contents_class[0].offset);
   EXPECT_EQ(AutocompleteMatch::ACMatchClassification::URL,
             match.contents_class[0].style);
@@ skipping 140 matching lines @@
     provider_->default_results_.verbatim_relevance =
         cases[i].verbatim_relevance;
     provider_->default_results_.navigation_results.clear();
     provider_->default_results_.suggest_results.clear();
     for (size_t j = 0; j < ARRAYSIZE_UNSAFE(cases[i].results); ++j) {
       const std::string& suggestion = cases[i].results[j].suggestion;
       if (suggestion == kNotApplicable)
         break;
       if (cases[i].results[j].is_navigation_result) {
         provider_->default_results_.navigation_results.push_back(
-            SearchProvider::NavigationResult(
-                *provider_, GURL(suggestion), string16(),
-                false, cases[i].results[j].relevance));
+            SearchProvider::NavigationResult(*provider_.get(),
+                                             GURL(suggestion),
+                                             string16(),
+                                             false,
+                                             cases[i].results[j].relevance));
       } else {
         provider_->default_results_.suggest_results.push_back(
             SearchProvider::SuggestResult(ASCIIToUTF16(suggestion), false,
                                           cases[i].results[j].relevance));
       }
     }
 
     provider_->input_ = AutocompleteInput(
         ASCIIToUTF16(cases[i].omnibox_input), string16::npos, string16(),
         GURL(), false, false, true, AutocompleteInput::ALL_MATCHES);
@@ skipping 21 matching lines @@
       } else {
         ASSERT_NE(sug_end, sug_it) << "Failed to find " << suggestion;
         EXPECT_EQ(ASCIIToUTF16(suggestion), sug_it->suggestion());
         ++sug_it;
       }
     }
     EXPECT_EQ(sug_end, sug_it);
     EXPECT_EQ(nav_end, nav_it);
   }
 }