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

chrome/browser/extensions/extension_service_unittest.cc

 // Copyright (c) 2013 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/extensions/extension_service_unittest.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
@@ skipping 440 matching lines @@
 
 void ExtensionServiceTestBase::InitializeExtensionService(
     const ExtensionServiceTestBase::ExtensionServiceInitParams& params) {
   TestingProfile::Builder profile_builder;
   // Create a PrefService that only contains user defined preference values.
   PrefServiceMockBuilder builder;
   builder.WithUserFilePrefs(
       params.pref_file, loop_.message_loop_proxy());
   scoped_refptr<user_prefs::PrefRegistrySyncable> registry(
       new user_prefs::PrefRegistrySyncable);
-  scoped_ptr<PrefServiceSyncable> prefs(builder.CreateSyncable(registry));
-  chrome::RegisterUserPrefs(registry);
+  scoped_ptr<PrefServiceSyncable> prefs(builder.CreateSyncable(registry.get()));
+  chrome::RegisterUserPrefs(registry.get());
   profile_builder.SetPrefService(prefs.Pass());
   profile_builder.SetPath(params.profile_path);
   profile_ = profile_builder.Build();
 
   TestExtensionSystem* system = static_cast<TestExtensionSystem*>(
       ExtensionSystem::Get(profile_.get()));
   if (!params.is_first_run) {
     ExtensionPrefs* prefs = system->CreateExtensionPrefs(
         CommandLine::ForCurrentProcess(),
         params.extensions_install_dir);
@@ skipping 323 matching lines @@
       if (install_state == INSTALL_UPDATED && !expected_old_name.empty())
         EXPECT_EQ(expected_old_name, old_name_);
       EXPECT_EQ(0u, errors.size()) << path.value();
 
       if (install_state == INSTALL_WITHOUT_LOAD) {
         EXPECT_EQ(0u, loaded_.size()) << path.value();
       } else {
         EXPECT_EQ(1u, loaded_.size()) << path.value();
         EXPECT_EQ(expected_extensions_count_, service_->extensions()->size()) <<
             path.value();
-        extension = loaded_[0];
-        EXPECT_TRUE(service_->GetExtensionById(extension->id(), false)) <<
-            path.value();
+        extension = loaded_[0].get();
+        EXPECT_TRUE(service_->GetExtensionById(extension->id(), false))
+            << path.value();
       }
 
       for (std::vector<string16>::iterator err = errors.begin();
         err != errors.end(); ++err) {
         LOG(ERROR) << *err;
       }
     } else {
       EXPECT_FALSE(installed_) << path.value();
       EXPECT_EQ(0u, loaded_.size()) << path.value();
       EXPECT_EQ(1u, errors.size()) << path.value();
@@ skipping 389 matching lines @@
   ValidateIntegerPref(good0, "location", Manifest::INTERNAL);
   ValidateIntegerPref(good1, "state", Extension::ENABLED);
   ValidateIntegerPref(good1, "location", Manifest::INTERNAL);
   ValidateIntegerPref(good2, "state", Extension::ENABLED);
   ValidateIntegerPref(good2, "location", Manifest::INTERNAL);
 
   URLPatternSet expected_patterns;
   AddPattern(&expected_patterns, "file:///*");
   AddPattern(&expected_patterns, "http://*.google.com/*");
   AddPattern(&expected_patterns, "https://*.google.com/*");
-  const Extension* extension = loaded_[0];
+  const Extension* extension = loaded_[0].get();
   const extensions::UserScriptList& scripts =
       extensions::ContentScriptsInfo::GetContentScripts(extension);
   ASSERT_EQ(2u, scripts.size());
   EXPECT_EQ(expected_patterns, scripts[0].url_patterns());
   EXPECT_EQ(2u, scripts[0].js_scripts().size());
   ExtensionResource resource00(extension->id(),
                                scripts[0].js_scripts()[0].extension_root(),
                                scripts[0].js_scripts()[0].relative_path());
   base::FilePath expected_path =
       base::MakeAbsoluteFilePath(extension->path().AppendASCII("script1.js"));
@@ skipping 19 matching lines @@
   expected_patterns.ClearPatterns();
   AddPattern(&expected_patterns, "http://*.google.com/*");
   AddPattern(&expected_patterns, "https://*.google.com/*");
   EXPECT_EQ(expected_patterns,
             extension->GetActivePermissions()->explicit_hosts());
 
   EXPECT_EQ(std::string(good1), loaded_[1]->id());
   EXPECT_EQ(std::string("My extension 2"), loaded_[1]->name());
   EXPECT_EQ(std::string(), loaded_[1]->description());
   EXPECT_EQ(loaded_[1]->GetResourceURL("background.html"),
-            extensions::BackgroundInfo::GetBackgroundURL(loaded_[1]));
-  EXPECT_EQ(
-      0u, extensions::ContentScriptsInfo::GetContentScripts(loaded_[1]).size());
+            extensions::BackgroundInfo::GetBackgroundURL(loaded_[1].get()));
+  EXPECT_EQ(0u,
+            extensions::ContentScriptsInfo::GetContentScripts(loaded_[1].get())
+                .size());
 
   // We don't parse the plugins section on Chrome OS.
 #if defined(OS_CHROMEOS)
   EXPECT_TRUE(!extensions::PluginInfo::HasPlugins(loaded_[1]));
 #else
-  ASSERT_TRUE(extensions::PluginInfo::HasPlugins(loaded_[1]));
+  ASSERT_TRUE(extensions::PluginInfo::HasPlugins(loaded_[1].get()));
   const std::vector<extensions::PluginInfo>* plugins =
-      extensions::PluginInfo::GetPlugins(loaded_[1]);
+      extensions::PluginInfo::GetPlugins(loaded_[1].get());
   ASSERT_TRUE(plugins);
   ASSERT_EQ(2u, plugins->size());
   EXPECT_EQ(loaded_[1]->path().AppendASCII("content_plugin.dll").value(),
             plugins->at(0).path.value());
   EXPECT_TRUE(plugins->at(0).is_public);
   EXPECT_EQ(loaded_[1]->path().AppendASCII("extension_plugin.dll").value(),
             plugins->at(1).path.value());
   EXPECT_FALSE(plugins->at(1).is_public);
 #endif
 
   EXPECT_EQ(Manifest::INTERNAL, loaded_[1]->location());
 
   int index = expected_num_extensions - 1;
   EXPECT_EQ(std::string(good2), loaded_[index]->id());
   EXPECT_EQ(std::string("My extension 3"), loaded_[index]->name());
   EXPECT_EQ(std::string(), loaded_[index]->description());
-  EXPECT_EQ(
-      0u,
-      extensions::ContentScriptsInfo::GetContentScripts(loaded_[index]).size());
+  EXPECT_EQ(0u,
+            extensions::ContentScriptsInfo::GetContentScripts(
+                loaded_[index].get()).size());
   EXPECT_EQ(Manifest::INTERNAL, loaded_[index]->location());
 };
 
 // Test loading bad extensions from the profile directory.
 TEST_F(ExtensionServiceTest, LoadAllExtensionsFromDirectoryFail) {
   // Initialize the test dir with a bad Preferences/extensions.
   base::FilePath source_install_dir = data_dir_
       .AppendASCII("bad")
       .AppendASCII("Extensions");
   base::FilePath pref_path = source_install_dir
@@ skipping 2902 matching lines @@
   ASSERT_EQ(0u, GetErrors().size());
   ASSERT_EQ(1u, loaded_.size());
   ASSERT_EQ("1.0.0.1", loaded_[0]->version()->GetString());
   ValidatePrefKeyCount(1);
   ValidateIntegerPref(good_crx, "state", Extension::ENABLED);
   ValidateIntegerPref(good_crx, "location", location);
 
   // Uninstall the extension and reload. Nothing should happen because the
   // preference should prevent us from reinstalling.
   std::string id = loaded_[0]->id();
-  bool no_uninstall = management_policy_->MustRemainEnabled(loaded_[0], NULL);
+  bool no_uninstall =
+      management_policy_->MustRemainEnabled(loaded_[0].get(), NULL);
   service_->UninstallExtension(id, false, NULL);
   loop_.RunUntilIdle();
 
   base::FilePath install_path = extensions_install_dir_.AppendASCII(id);
   if (no_uninstall) {
     // Policy controlled extensions should not have been touched by uninstall.
     ASSERT_TRUE(file_util::PathExists(install_path));
   } else {
     // The extension should also be gone from the install directory.
     ASSERT_FALSE(file_util::PathExists(install_path));
@@ skipping 11 matching lines @@
 
     loaded_.clear();
     service_->CheckForExternalUpdates();
     loop_.RunUntilIdle();
     ASSERT_EQ(1u, loaded_.size());
   }
   ValidatePrefKeyCount(1);
   ValidateIntegerPref(good_crx, "state", Extension::ENABLED);
   ValidateIntegerPref(good_crx, "location", location);
 
-  if (management_policy_->MustRemainEnabled(loaded_[0], NULL)) {
+  if (management_policy_->MustRemainEnabled(loaded_[0].get(), NULL)) {
     EXPECT_EQ(2, provider->visit_count());
   } else {
     // Now test an externally triggered uninstall (deleting the registry key or
     // the pref entry).
     provider->RemoveExtension(good_crx);
 
     loaded_.clear();
     service_->OnExternalProviderReady(provider);
     loop_.RunUntilIdle();
     ASSERT_EQ(0u, loaded_.size());
@@ skipping 1757 matching lines @@
       new MockExtensionProvider(service_, Manifest::EXTERNAL_PREF);
   AddMockExternalProvider(provider);
   provider->UpdateOrAddExtension(updates_from_webstore, "1", crx_path);
 
   service_->CheckForExternalUpdates();
   loop_.RunUntilIdle();
   EXPECT_TRUE(extensions::HasExternalInstallError(service_));
   EXPECT_FALSE(extensions::HasExternalInstallBubble(service_));
   EXPECT_FALSE(service_->IsExtensionEnabled(updates_from_webstore));
 }