Remove implicit conversions from scoped_refptr to T* in chrome/browser/extensions/

chrome/browser/extensions/shared_module_service_unittest.cc

 // Copyright 2014 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/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string16.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_service_test_base.h"
@@ skipping 96 matching lines @@
       CreateExtensionImportingModule(import_id, extension_id, "1.0");
 
   PendingExtensionManager* pending_extension_manager =
       service()->pending_extension_manager();
 
   // Verify that we don't currently want to install the imported module.
   EXPECT_FALSE(pending_extension_manager->IsIdPending(import_id));
 
   // Try to satisfy imports for the extension. This should queue the imported
   // module's installation.
-  service()->shared_module_service()->SatisfyImports(extension);
+  service()->shared_module_service()->SatisfyImports(extension.get());
   EXPECT_TRUE(pending_extension_manager->IsIdPending(import_id));
 }
 
 TEST_F(SharedModuleServiceUnitTest, PruneSharedModulesOnUninstall) {
   // Create a module which exports a resource, and install it.
   scoped_ptr<base::DictionaryValue> manifest =
       DictionaryBuilder()
           .Set("name", "Shared Module")
           .Set("version", "1.0")
           .Set("manifest_version", 2)
           .Set("export",
                DictionaryBuilder().Set("resources",
                                        ListBuilder().Append("foo.js"))).Build();
   scoped_refptr<Extension> shared_module =
       ExtensionBuilder()
           .SetManifest(manifest.Pass())
           .AddFlags(Extension::FROM_WEBSTORE)
           .SetID(crx_file::id_util::GenerateId("shared_module"))
           .Build();
 
-  EXPECT_TRUE(InstallExtension(shared_module, false));
+  EXPECT_TRUE(InstallExtension(shared_module.get(), false));
 
   std::string extension_id = crx_file::id_util::GenerateId("extension_id");
   // Create and install an extension that imports our new module.
   scoped_refptr<Extension> importing_extension =
       CreateExtensionImportingModule(shared_module->id(), extension_id, "1.0");
-  EXPECT_TRUE(InstallExtension(importing_extension, false));
+  EXPECT_TRUE(InstallExtension(importing_extension.get(), false));
 
   // Uninstall the extension that imports our module.
   base::string16 error;
   service()->UninstallExtension(importing_extension->id(),
                                 extensions::UNINSTALL_REASON_FOR_TESTING,
                                 base::Bind(&base::DoNothing),
                                 &error);
   EXPECT_TRUE(error.empty());
 
   // Since the module was only referenced by that single extension, it should
@@ skipping 12 matching lines @@
           .Set("manifest_version", 2)
           .Set("export",
                DictionaryBuilder().Set("resources",
                                        ListBuilder().Append("foo.js"))).Build();
   scoped_refptr<Extension> shared_module_1 =
       ExtensionBuilder()
           .SetManifest(manifest_1.Pass())
           .AddFlags(Extension::FROM_WEBSTORE)
           .SetID(crx_file::id_util::GenerateId("shared_module_1"))
           .Build();
-  EXPECT_TRUE(InstallExtension(shared_module_1, false));
+  EXPECT_TRUE(InstallExtension(shared_module_1.get(), false));
 
   scoped_ptr<base::DictionaryValue> manifest_2 =
       DictionaryBuilder()
           .Set("name", "Shared Module 2")
           .Set("version", "1.0")
           .Set("manifest_version", 2)
           .Set("export",
                DictionaryBuilder().Set("resources",
                                        ListBuilder().Append("foo.js"))).Build();
   scoped_refptr<Extension> shared_module_2 =
       ExtensionBuilder()
           .SetManifest(manifest_2.Pass())
           .AddFlags(Extension::FROM_WEBSTORE)
           .SetID(crx_file::id_util::GenerateId("shared_module_2"))
           .Build();
-  EXPECT_TRUE(InstallExtension(shared_module_2, false));
+  EXPECT_TRUE(InstallExtension(shared_module_2.get(), false));
 
   std::string extension_id = crx_file::id_util::GenerateId("extension_id");
 
   // Create and install an extension v1.0 that imports our new module 1.
   scoped_refptr<Extension> importing_extension_1 =
       CreateExtensionImportingModule(shared_module_1->id(),
                                      extension_id,
                                      "1.0");
-  EXPECT_TRUE(InstallExtension(importing_extension_1, false));
+  EXPECT_TRUE(InstallExtension(importing_extension_1.get(), false));
 
   // Create and install a new version of the extension that imports our new
   // module 2.
   scoped_refptr<Extension> importing_extension_2 =
       CreateExtensionImportingModule(shared_module_2->id(),
                                      extension_id,
                                      "1.1");
-  EXPECT_TRUE(InstallExtension(importing_extension_2, true));
+  EXPECT_TRUE(InstallExtension(importing_extension_2.get(), true));
 
   // Since the extension v1.1 depends the module 2 insteand module 1.
   // So the module 1 should be uninstalled.
   EXPECT_FALSE(registry()->GetExtensionById(shared_module_1->id(),
                                             ExtensionRegistry::EVERYTHING));
   EXPECT_TRUE(registry()->GetExtensionById(shared_module_2->id(),
                                             ExtensionRegistry::EVERYTHING));
 
   // Create and install a new version of the extension that does not import any
   // module.
   scoped_refptr<Extension> importing_extension_3 =
       CreateExtensionImportingModule("", extension_id, "1.2");
-  EXPECT_TRUE(InstallExtension(importing_extension_3, true));
+  EXPECT_TRUE(InstallExtension(importing_extension_3.get(), true));
 
   // Since the extension v1.2 does not depend any module, so the all models
   // should have been uninstalled.
   EXPECT_FALSE(registry()->GetExtensionById(shared_module_1->id(),
                                             ExtensionRegistry::EVERYTHING));
   EXPECT_FALSE(registry()->GetExtensionById(shared_module_2->id(),
                                             ExtensionRegistry::EVERYTHING));
 
 }
 
@@ skipping 13 matching lines @@
                                            .Append(whitelisted_id))
                                   .Set("resources",
                                        ListBuilder().Append("*"))).Build();
   scoped_refptr<Extension> shared_module =
       ExtensionBuilder()
           .SetManifest(manifest.Pass())
           .AddFlags(Extension::FROM_WEBSTORE)
           .SetID(crx_file::id_util::GenerateId("shared_module"))
           .Build();
 
-  EXPECT_TRUE(InstallExtension(shared_module, false));
+  EXPECT_TRUE(InstallExtension(shared_module.get(), false));
 
   // Create and install an extension with the whitelisted ID.
   scoped_refptr<Extension> whitelisted_extension =
       CreateExtensionImportingModule(shared_module->id(),
                                      whitelisted_id,
                                      "1.0");
-  EXPECT_TRUE(InstallExtension(whitelisted_extension, false));
+  EXPECT_TRUE(InstallExtension(whitelisted_extension.get(), false));
 
   // Try to install an extension with an ID that is not whitelisted.
   scoped_refptr<Extension> nonwhitelisted_extension =
       CreateExtensionImportingModule(shared_module->id(),
                                      nonwhitelisted_id,
                                      "1.0");
-  EXPECT_FALSE(InstallExtension(nonwhitelisted_extension, false));
+  EXPECT_FALSE(InstallExtension(nonwhitelisted_extension.get(), false));
 }
 
 }  // namespace extensions