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

chrome/browser/extensions/extension_messages_apitest.cc

 // Copyright (c) 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 "base/base64.h"
 #include "base/files/file_path.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/path_service.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 443 matching lines @@
       ExtensionBuilder()
           .SetID("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
           .SetManifest(DictionaryBuilder()
                            .Set("name", "Fake extension")
                            .Set("version", "1")
                            .Set("manifest_version", 2))
           .Build();
 
   ui_test_utils::NavigateToURL(browser(), chromium_org_url());
   EXPECT_EQ(NAMESPACE_NOT_DEFINED,
-            CanConnectAndSendMessagesToMainFrame(extension));
+            CanConnectAndSendMessagesToMainFrame(extension.get()));
   EXPECT_FALSE(AreAnyNonWebApisDefinedForMainFrame());
 
   ui_test_utils::NavigateToURL(browser(), google_com_url());
   EXPECT_EQ(NAMESPACE_NOT_DEFINED,
-            CanConnectAndSendMessagesToMainFrame(extension));
+            CanConnectAndSendMessagesToMainFrame(extension.get()));
   EXPECT_FALSE(AreAnyNonWebApisDefinedForMainFrame());
 }
 
 // Tests two extensions on the same sites: one web connectable, one not.
 IN_PROC_BROWSER_TEST_F(ExternallyConnectableMessagingTest,
                        WebConnectableAndNotConnectable) {
   InitializeTestServer();
 
   // Install the web connectable extension. chromium.org can connect to it,
   // google.com can't.
-  const Extension* chromium_connectable = LoadChromiumConnectableExtension();
+  scoped_refptr<const Extension> chromium_connectable =
+      LoadChromiumConnectableExtension();
 
   ui_test_utils::NavigateToURL(browser(), chromium_org_url());
-  EXPECT_EQ(OK, CanConnectAndSendMessagesToMainFrame(chromium_connectable));
+  EXPECT_EQ(OK,
+            CanConnectAndSendMessagesToMainFrame(chromium_connectable.get()));
   EXPECT_FALSE(AreAnyNonWebApisDefinedForMainFrame());
 
   ui_test_utils::NavigateToURL(browser(), google_com_url());
   EXPECT_EQ(NAMESPACE_NOT_DEFINED,
-            CanConnectAndSendMessagesToMainFrame(chromium_connectable));
+            CanConnectAndSendMessagesToMainFrame(chromium_connectable.get()));
   EXPECT_FALSE(AreAnyNonWebApisDefinedForMainFrame());
 
   // Install the non-connectable extension. Nothing can connect to it.
-  const Extension* not_connectable = LoadNotConnectableExtension();
+  scoped_refptr<const Extension> not_connectable =
+      LoadNotConnectableExtension();
 
   ui_test_utils::NavigateToURL(browser(), chromium_org_url());
   // Namespace will be defined here because |chromium_connectable| can connect
   // to it - so this will be the "cannot establish connection" error.
   EXPECT_EQ(COULD_NOT_ESTABLISH_CONNECTION_ERROR,
-            CanConnectAndSendMessagesToMainFrame(not_connectable));
+            CanConnectAndSendMessagesToMainFrame(not_connectable.get()));
   EXPECT_FALSE(AreAnyNonWebApisDefinedForMainFrame());
 
   ui_test_utils::NavigateToURL(browser(), google_com_url());
   EXPECT_EQ(NAMESPACE_NOT_DEFINED,
-            CanConnectAndSendMessagesToMainFrame(not_connectable));
+            CanConnectAndSendMessagesToMainFrame(not_connectable.get()));
   EXPECT_FALSE(AreAnyNonWebApisDefinedForMainFrame());
 }
 
 // See http://crbug.com/297866
 IN_PROC_BROWSER_TEST_F(ExternallyConnectableMessagingTest,
                        DISABLED_BackgroundPageClosesOnMessageReceipt) {
   InitializeTestServer();
 
   // Install the web connectable extension.
-  const Extension* chromium_connectable = LoadChromiumConnectableExtension();
+  scoped_refptr<const Extension> chromium_connectable =
+      LoadChromiumConnectableExtension();
 
   ui_test_utils::NavigateToURL(browser(), chromium_org_url());
   // If the background page closes after receipt of the message, it will still
   // reply to this message...
   EXPECT_EQ(OK,
-            CanConnectAndSendMessagesToMainFrame(chromium_connectable,
+            CanConnectAndSendMessagesToMainFrame(chromium_connectable.get(),
                                                  close_background_message()));
   // and be re-opened by receipt of a subsequent message.
-  EXPECT_EQ(OK, CanConnectAndSendMessagesToMainFrame(chromium_connectable));
+  EXPECT_EQ(OK,
+            CanConnectAndSendMessagesToMainFrame(chromium_connectable.get()));
 }
 
 // Tests a web connectable extension that doesn't receive TLS channel id.
 IN_PROC_BROWSER_TEST_F(ExternallyConnectableMessagingTest,
                        WebConnectableWithoutTlsChannelId) {
   InitializeTestServer();
 
   // Install the web connectable extension. chromium.org can connect to it,
   // google.com can't.
-  const Extension* chromium_connectable = LoadChromiumConnectableExtension();
-  ASSERT_TRUE(chromium_connectable);
+  scoped_refptr<const Extension> chromium_connectable =
+      LoadChromiumConnectableExtension();
+  ASSERT_TRUE(chromium_connectable.get());
 
   ui_test_utils::NavigateToURL(browser(), chromium_org_url());
   // The web connectable extension doesn't request the TLS channel ID, so it
   // doesn't get it, whether or not the page asks for it.
   EXPECT_EQ(std::string(),
-            GetTlsChannelIdFromPortConnect(chromium_connectable, false));
+            GetTlsChannelIdFromPortConnect(chromium_connectable.get(), false));
   EXPECT_EQ(std::string(),
-            GetTlsChannelIdFromSendMessage(chromium_connectable, true));
+            GetTlsChannelIdFromSendMessage(chromium_connectable.get(), true));
   EXPECT_EQ(std::string(),
-            GetTlsChannelIdFromPortConnect(chromium_connectable, false));
+            GetTlsChannelIdFromPortConnect(chromium_connectable.get(), false));
   EXPECT_EQ(std::string(),
-            GetTlsChannelIdFromSendMessage(chromium_connectable, true));
+            GetTlsChannelIdFromSendMessage(chromium_connectable.get(), true));
 }
 
 // Tests a web connectable extension that receives TLS channel id with a site
 // that can't connect to it.
 IN_PROC_BROWSER_TEST_F(ExternallyConnectableMessagingTest,
                        WebConnectableWithTlsChannelIdWithNonMatchingSite) {
   InitializeTestServer();
 
-  const Extension* chromium_connectable =
+  scoped_refptr<const Extension> chromium_connectable =
       LoadChromiumConnectableExtensionWithTlsChannelId();
-  ASSERT_TRUE(chromium_connectable);
+  ASSERT_TRUE(chromium_connectable.get());
 
   ui_test_utils::NavigateToURL(browser(), google_com_url());
   // The extension requests the TLS channel ID, but it doesn't get it for a
   // site that can't connect to it, regardless of whether the page asks for it.
   EXPECT_EQ(base::StringPrintf("%d", NAMESPACE_NOT_DEFINED),
-            GetTlsChannelIdFromPortConnect(chromium_connectable, false));
+            GetTlsChannelIdFromPortConnect(chromium_connectable.get(), false));
   EXPECT_EQ(base::StringPrintf("%d", NAMESPACE_NOT_DEFINED),
-            GetTlsChannelIdFromSendMessage(chromium_connectable, true));
+            GetTlsChannelIdFromSendMessage(chromium_connectable.get(), true));
   EXPECT_EQ(base::StringPrintf("%d", NAMESPACE_NOT_DEFINED),
-            GetTlsChannelIdFromPortConnect(chromium_connectable, false));
+            GetTlsChannelIdFromPortConnect(chromium_connectable.get(), false));
   EXPECT_EQ(base::StringPrintf("%d", NAMESPACE_NOT_DEFINED),
-            GetTlsChannelIdFromSendMessage(chromium_connectable, true));
+            GetTlsChannelIdFromSendMessage(chromium_connectable.get(), true));
 }
 
 // Tests a web connectable extension that receives TLS channel id on a site
 // that can connect to it, but with no TLS channel ID having been generated.
 IN_PROC_BROWSER_TEST_F(ExternallyConnectableMessagingTest,
                        WebConnectableWithTlsChannelIdWithEmptyTlsChannelId) {
   InitializeTestServer();
 
-  const Extension* chromium_connectable =
+  scoped_refptr<const Extension> chromium_connectable =
       LoadChromiumConnectableExtensionWithTlsChannelId();
-  ASSERT_TRUE(chromium_connectable);
+  ASSERT_TRUE(chromium_connectable.get());
 
   ui_test_utils::NavigateToURL(browser(), chromium_org_url());
 
   // Since the extension requests the TLS channel ID, it gets it for a site that
   // can connect to it, but only if the page also asks to include it.
   EXPECT_EQ(std::string(),
-            GetTlsChannelIdFromPortConnect(chromium_connectable, false));
+            GetTlsChannelIdFromPortConnect(chromium_connectable.get(), false));
   EXPECT_EQ(std::string(),
-            GetTlsChannelIdFromSendMessage(chromium_connectable, false));
+            GetTlsChannelIdFromSendMessage(chromium_connectable.get(), false));
   // If the page does ask for it, it isn't empty.
   std::string tls_channel_id =
-      GetTlsChannelIdFromPortConnect(chromium_connectable, true);
+      GetTlsChannelIdFromPortConnect(chromium_connectable.get(), true);
   // Because the TLS channel ID has never been generated for this domain,
   // no TLS channel ID is reported.
   EXPECT_EQ(std::string(), tls_channel_id);
 }
 
 // Flaky on Linux and Windows. http://crbug.com/315264
 // Tests a web connectable extension that receives TLS channel id, but
 // immediately closes its background page upon receipt of a message.
 IN_PROC_BROWSER_TEST_F(ExternallyConnectableMessagingTest,
     DISABLED_WebConnectableWithEmptyTlsChannelIdAndClosedBackgroundPage) {
   InitializeTestServer();
 
-  const Extension* chromium_connectable =
+  scoped_refptr<const Extension> chromium_connectable =
       LoadChromiumConnectableExtensionWithTlsChannelId();
 
   ui_test_utils::NavigateToURL(browser(), chromium_org_url());
   // If the page does ask for it, it isn't empty, even if the background page
   // closes upon receipt of the connect.
   std::string tls_channel_id = GetTlsChannelIdFromPortConnect(
-      chromium_connectable, true, close_background_message());
+      chromium_connectable.get(), true, close_background_message());
   // Because the TLS channel ID has never been generated for this domain,
   // no TLS channel ID is reported.
   EXPECT_EQ(std::string(), tls_channel_id);
   // A subsequent connect will still succeed, even if the background page was
   // previously closed.
-  tls_channel_id = GetTlsChannelIdFromPortConnect(chromium_connectable, true);
+  tls_channel_id =
+      GetTlsChannelIdFromPortConnect(chromium_connectable.get(), true);
    // And the empty value is still retrieved.
   EXPECT_EQ(std::string(), tls_channel_id);
 }
 
 // Tests that enabling and disabling an extension makes the runtime bindings
 // appear and disappear.
 //
 // TODO(kalman): Test with multiple extensions that can be accessed by the same
 // host.
 IN_PROC_BROWSER_TEST_F(ExternallyConnectableMessagingTest,
                        EnablingAndDisabling) {
   InitializeTestServer();
 
-  const Extension* chromium_connectable = LoadChromiumConnectableExtension();
-  const Extension* not_connectable = LoadNotConnectableExtension();
+  scoped_refptr<const Extension> chromium_connectable =
+      LoadChromiumConnectableExtension();
+  scoped_refptr<const Extension> not_connectable =
+      LoadNotConnectableExtension();
 
   ui_test_utils::NavigateToURL(browser(), chromium_org_url());
-  EXPECT_EQ(OK, CanConnectAndSendMessagesToMainFrame(chromium_connectable));
+  EXPECT_EQ(OK,
+            CanConnectAndSendMessagesToMainFrame(chromium_connectable.get()));
   EXPECT_EQ(COULD_NOT_ESTABLISH_CONNECTION_ERROR,
-            CanConnectAndSendMessagesToMainFrame(not_connectable));
+            CanConnectAndSendMessagesToMainFrame(not_connectable.get()));
 
   DisableExtension(chromium_connectable->id());
   EXPECT_EQ(COULD_NOT_ESTABLISH_CONNECTION_ERROR,
-            CanConnectAndSendMessagesToMainFrame(chromium_connectable));
+            CanConnectAndSendMessagesToMainFrame(chromium_connectable.get()));
 
   EnableExtension(chromium_connectable->id());
-  EXPECT_EQ(OK, CanConnectAndSendMessagesToMainFrame(chromium_connectable));
+  EXPECT_EQ(OK,
+            CanConnectAndSendMessagesToMainFrame(chromium_connectable.get()));
   EXPECT_EQ(COULD_NOT_ESTABLISH_CONNECTION_ERROR,
-            CanConnectAndSendMessagesToMainFrame(not_connectable));
+            CanConnectAndSendMessagesToMainFrame(not_connectable.get()));
 }
 
 // Tests connection from incognito tabs when the user denies the connection
 // request. Spanning mode only. A separate test for apps and extensions.
 //
 // TODO(kalman): ensure that we exercise split vs spanning incognito logic
 // somewhere. This is a test that should be shared with the content script logic
 // so it's not really our specific concern for web connectable.
 //
 // TODO(kalman): test messages from incognito extensions too.
 IN_PROC_BROWSER_TEST_F(ExternallyConnectableMessagingTest,
                        FromIncognitoDenyApp) {
   InitializeTestServer();
 
   scoped_refptr<const Extension> app = LoadChromiumConnectableApp();
   ASSERT_TRUE(app->is_platform_app());
 
   Browser* incognito_browser = ui_test_utils::OpenURLOffTheRecord(
       profile()->GetOffTheRecordProfile(),
       chromium_org_url());
   content::RenderFrameHost* incognito_frame = incognito_browser->
       tab_strip_model()->GetActiveWebContents()->GetMainFrame();
 
   {
     IncognitoConnectability::ScopedAlertTracker alert_tracker(
         IncognitoConnectability::ScopedAlertTracker::ALWAYS_DENY);
 
     // No connection because incognito-enabled hasn't been set for the app, and
     // the user denied our interactive request.
-    EXPECT_EQ(COULD_NOT_ESTABLISH_CONNECTION_ERROR,
-              CanConnectAndSendMessagesToFrame(incognito_frame, app, NULL));
+    EXPECT_EQ(
+        COULD_NOT_ESTABLISH_CONNECTION_ERROR,
+        CanConnectAndSendMessagesToFrame(incognito_frame, app.get(), NULL));
     EXPECT_EQ(1, alert_tracker.GetAndResetAlertCount());
 
     // Try again. User has already denied so alert not shown.
-    EXPECT_EQ(COULD_NOT_ESTABLISH_CONNECTION_ERROR,
-              CanConnectAndSendMessagesToFrame(incognito_frame, app, NULL));
+    EXPECT_EQ(
+        COULD_NOT_ESTABLISH_CONNECTION_ERROR,
+        CanConnectAndSendMessagesToFrame(incognito_frame, app.get(), NULL));
     EXPECT_EQ(0, alert_tracker.GetAndResetAlertCount());
   }
 
   // It's not possible to allow an app in incognito.
   ExtensionPrefs::Get(profile())->SetIsIncognitoEnabled(app->id(), true);
   EXPECT_EQ(COULD_NOT_ESTABLISH_CONNECTION_ERROR,
-            CanConnectAndSendMessagesToFrame(incognito_frame, app, NULL));
+            CanConnectAndSendMessagesToFrame(incognito_frame, app.get(), NULL));
 }
 
 IN_PROC_BROWSER_TEST_F(ExternallyConnectableMessagingTest,
                        FromIncognitoDenyExtension) {
   InitializeTestServer();
 
   scoped_refptr<const Extension> extension = LoadChromiumConnectableExtension();
 
   Browser* incognito_browser = ui_test_utils::OpenURLOffTheRecord(
       profile()->GetOffTheRecordProfile(), chromium_org_url());
   content::RenderFrameHost* incognito_frame =
       incognito_browser->tab_strip_model()
           ->GetActiveWebContents()
           ->GetMainFrame();
 
   {
     IncognitoConnectability::ScopedAlertTracker alert_tracker(
         IncognitoConnectability::ScopedAlertTracker::ALWAYS_DENY);
 
     // The alert doesn't show for extensions.
-    EXPECT_EQ(
-        COULD_NOT_ESTABLISH_CONNECTION_ERROR,
-        CanConnectAndSendMessagesToFrame(incognito_frame, extension, NULL));
+    EXPECT_EQ(COULD_NOT_ESTABLISH_CONNECTION_ERROR,
+              CanConnectAndSendMessagesToFrame(
+                  incognito_frame, extension.get(), NULL));
     EXPECT_EQ(0, alert_tracker.GetAndResetAlertCount());
   }
 
   // Allowing the extension in incognito mode will bypass the deny.
   ExtensionPrefs::Get(profile())->SetIsIncognitoEnabled(extension->id(), true);
-  EXPECT_EQ(OK,
-            CanConnectAndSendMessagesToFrame(incognito_frame, extension, NULL));
+  EXPECT_EQ(
+      OK,
+      CanConnectAndSendMessagesToFrame(incognito_frame, extension.get(), NULL));
 }
 
 // Tests connection from incognito tabs when the user accepts the connection
 // request. Spanning mode only. Separate tests for apps and extensions.
 //
 // TODO(kalman): see comment above about split mode.
 IN_PROC_BROWSER_TEST_F(ExternallyConnectableMessagingTest,
                        FromIncognitoAllowApp) {
   InitializeTestServer();
 
   scoped_refptr<const Extension> app = LoadChromiumConnectableApp();
   ASSERT_TRUE(app->is_platform_app());
 
   Browser* incognito_browser = ui_test_utils::OpenURLOffTheRecord(
       profile()->GetOffTheRecordProfile(),
       chromium_org_url());
   content::RenderFrameHost* incognito_frame = incognito_browser->
       tab_strip_model()->GetActiveWebContents()->GetMainFrame();
 
   {
     IncognitoConnectability::ScopedAlertTracker alert_tracker(
         IncognitoConnectability::ScopedAlertTracker::ALWAYS_ALLOW);
 
     // Connection allowed even with incognito disabled, because the user
     // accepted the interactive request.
-    EXPECT_EQ(OK, CanConnectAndSendMessagesToFrame(incognito_frame, app, NULL));
+    EXPECT_EQ(
+        OK, CanConnectAndSendMessagesToFrame(incognito_frame, app.get(), NULL));
     EXPECT_EQ(1, alert_tracker.GetAndResetAlertCount());
 
     // Try again. User has already allowed.
-    EXPECT_EQ(OK, CanConnectAndSendMessagesToFrame(incognito_frame, app, NULL));
+    EXPECT_EQ(
+        OK, CanConnectAndSendMessagesToFrame(incognito_frame, app.get(), NULL));
     EXPECT_EQ(0, alert_tracker.GetAndResetAlertCount());
   }
 
   // Apps can't be allowed in incognito mode, but it's moot because it's
   // already allowed.
   ExtensionPrefs::Get(profile())->SetIsIncognitoEnabled(app->id(), true);
-  EXPECT_EQ(OK, CanConnectAndSendMessagesToFrame(incognito_frame, app, NULL));
+  EXPECT_EQ(OK,
+            CanConnectAndSendMessagesToFrame(incognito_frame, app.get(), NULL));
 }
 
 IN_PROC_BROWSER_TEST_F(ExternallyConnectableMessagingTest,
                        FromIncognitoAllowExtension) {
   InitializeTestServer();
 
   scoped_refptr<const Extension> extension = LoadChromiumConnectableExtension();
 
   Browser* incognito_browser = ui_test_utils::OpenURLOffTheRecord(
       profile()->GetOffTheRecordProfile(), chromium_org_url());
   content::RenderFrameHost* incognito_frame =
       incognito_browser->tab_strip_model()
           ->GetActiveWebContents()
           ->GetMainFrame();
 
   {
     IncognitoConnectability::ScopedAlertTracker alert_tracker(
         IncognitoConnectability::ScopedAlertTracker::ALWAYS_ALLOW);
 
     // No alert is shown.
-    EXPECT_EQ(
-        COULD_NOT_ESTABLISH_CONNECTION_ERROR,
-        CanConnectAndSendMessagesToFrame(incognito_frame, extension, NULL));
+    EXPECT_EQ(COULD_NOT_ESTABLISH_CONNECTION_ERROR,
+              CanConnectAndSendMessagesToFrame(
+                  incognito_frame, extension.get(), NULL));
     EXPECT_EQ(0, alert_tracker.GetAndResetAlertCount());
   }
 
   // Allowing the extension in incognito mode is what allows connections.
   ExtensionPrefs::Get(profile())->SetIsIncognitoEnabled(extension->id(), true);
-  EXPECT_EQ(OK,
-            CanConnectAndSendMessagesToFrame(incognito_frame, extension, NULL));
+  EXPECT_EQ(
+      OK,
+      CanConnectAndSendMessagesToFrame(incognito_frame, extension.get(), NULL));
 }
 
 // Tests a connection from an iframe within a tab which doesn't have
 // permission. Iframe should work.
 IN_PROC_BROWSER_TEST_F(ExternallyConnectableMessagingTest,
                        FromIframeWithPermission) {
   InitializeTestServer();
 
-  const Extension* extension = LoadChromiumConnectableExtension();
+  scoped_refptr<const Extension> extension = LoadChromiumConnectableExtension();
 
   ui_test_utils::NavigateToURL(browser(), google_com_url());
   EXPECT_EQ(NAMESPACE_NOT_DEFINED,
-            CanConnectAndSendMessagesToMainFrame(extension));
+            CanConnectAndSendMessagesToMainFrame(extension.get()));
   EXPECT_FALSE(AreAnyNonWebApisDefinedForMainFrame());
 
   ASSERT_TRUE(AppendIframe(chromium_org_url()));
 
-  EXPECT_EQ(OK, CanConnectAndSendMessagesToIFrame(extension));
+  EXPECT_EQ(OK, CanConnectAndSendMessagesToIFrame(extension.get()));
   EXPECT_FALSE(AreAnyNonWebApisDefinedForIFrame());
 }
 
 // Tests connection from an iframe without permission within a tab that does.
 // Iframe shouldn't work.
 IN_PROC_BROWSER_TEST_F(ExternallyConnectableMessagingTest,
                        FromIframeWithoutPermission) {
   InitializeTestServer();
 
-  const Extension* extension = LoadChromiumConnectableExtension();
+  scoped_refptr<const Extension> extension = LoadChromiumConnectableExtension();
 
   ui_test_utils::NavigateToURL(browser(), chromium_org_url());
-  EXPECT_EQ(OK, CanConnectAndSendMessagesToMainFrame(extension));
+  EXPECT_EQ(OK, CanConnectAndSendMessagesToMainFrame(extension.get()));
   EXPECT_FALSE(AreAnyNonWebApisDefinedForMainFrame());
 
   ASSERT_TRUE(AppendIframe(google_com_url()));
 
   EXPECT_EQ(NAMESPACE_NOT_DEFINED,
-            CanConnectAndSendMessagesToIFrame(extension));
+            CanConnectAndSendMessagesToIFrame(extension.get()));
   EXPECT_FALSE(AreAnyNonWebApisDefinedForIFrame());
 }
 
 // Tests externally_connectable between a web page and an extension with a
 // TLS channel ID created for the origin.
 class ExternallyConnectableMessagingWithTlsChannelIdTest :
   public ExternallyConnectableMessagingTest {
  public:
   ExternallyConnectableMessagingWithTlsChannelIdTest()
       : tls_channel_id_created_(false, false) {
@@ skipping 58 matching lines @@
   base::WaitableEvent tls_channel_id_created_;
 };
 
 // Tests a web connectable extension that receives TLS channel id on a site
 // that can connect to it, with a TLS channel ID having been generated.
 IN_PROC_BROWSER_TEST_F(ExternallyConnectableMessagingWithTlsChannelIdTest,
                        WebConnectableWithNonEmptyTlsChannelId) {
   InitializeTestServer();
   std::string expected_tls_channel_id_value = CreateTlsChannelId();
 
-  const Extension* chromium_connectable =
+  scoped_refptr<const Extension> chromium_connectable =
       LoadChromiumConnectableExtensionWithTlsChannelId();
-  ASSERT_TRUE(chromium_connectable);
+  ASSERT_TRUE(chromium_connectable.get());
 
   ui_test_utils::NavigateToURL(browser(), chromium_org_url());
 
   // Since the extension requests the TLS channel ID, it gets it for a site that
   // can connect to it, but only if the page also asks to send it.
   EXPECT_EQ(std::string(),
-            GetTlsChannelIdFromPortConnect(chromium_connectable, false));
+            GetTlsChannelIdFromPortConnect(chromium_connectable.get(), false));
   EXPECT_EQ(std::string(),
-            GetTlsChannelIdFromSendMessage(chromium_connectable, false));
+            GetTlsChannelIdFromSendMessage(chromium_connectable.get(), false));
 
   // If the page does ask to send the TLS channel ID, it's sent and non-empty.
   std::string tls_channel_id_from_port_connect =
-      GetTlsChannelIdFromPortConnect(chromium_connectable, true);
+      GetTlsChannelIdFromPortConnect(chromium_connectable.get(), true);
   EXPECT_NE(0u, tls_channel_id_from_port_connect.size());
 
   // The same value is received by both connect and sendMessage.
   std::string tls_channel_id_from_send_message =
-      GetTlsChannelIdFromSendMessage(chromium_connectable, true);
+      GetTlsChannelIdFromSendMessage(chromium_connectable.get(), true);
   EXPECT_EQ(tls_channel_id_from_port_connect, tls_channel_id_from_send_message);
 
   // And since a TLS channel ID exists for the domain, the value received is
   // parseable as a JWK. (In particular, it has the same value we created by
   // converting the public key to JWK with net::ConvertSpkiFromDerToJwk.)
   std::string tls_channel_id(tls_channel_id_from_port_connect);
   EXPECT_EQ(expected_tls_channel_id_value, tls_channel_id);
 
   // The TLS channel ID shouldn't change from one connection to the next...
   std::string tls_channel_id2 =
-      GetTlsChannelIdFromPortConnect(chromium_connectable, true);
+      GetTlsChannelIdFromPortConnect(chromium_connectable.get(), true);
   EXPECT_EQ(tls_channel_id, tls_channel_id2);
-  tls_channel_id2 = GetTlsChannelIdFromSendMessage(chromium_connectable, true);
+  tls_channel_id2 =
+      GetTlsChannelIdFromSendMessage(chromium_connectable.get(), true);
   EXPECT_EQ(tls_channel_id, tls_channel_id2);
 
   // nor should it change when navigating away, revisiting the page and
   // requesting it again.
   ui_test_utils::NavigateToURL(browser(), google_com_url());
   ui_test_utils::NavigateToURL(browser(), chromium_org_url());
-  tls_channel_id2 = GetTlsChannelIdFromPortConnect(chromium_connectable, true);
+  tls_channel_id2 =
+      GetTlsChannelIdFromPortConnect(chromium_connectable.get(), true);
   EXPECT_EQ(tls_channel_id, tls_channel_id2);
-  tls_channel_id2 = GetTlsChannelIdFromSendMessage(chromium_connectable, true);
+  tls_channel_id2 =
+      GetTlsChannelIdFromSendMessage(chromium_connectable.get(), true);
   EXPECT_EQ(tls_channel_id, tls_channel_id2);
 }
 
 // Tests a web connectable extension that receives TLS channel id, but
 // immediately closes its background page upon receipt of a message.
 // Same flakiness seen in http://crbug.com/297866
 IN_PROC_BROWSER_TEST_F(ExternallyConnectableMessagingWithTlsChannelIdTest,
     DISABLED_WebConnectableWithNonEmptyTlsChannelIdAndClosedBackgroundPage) {
   InitializeTestServer();
   std::string expected_tls_channel_id_value = CreateTlsChannelId();
 
-  const Extension* chromium_connectable =
+  scoped_refptr<const Extension> chromium_connectable =
       LoadChromiumConnectableExtensionWithTlsChannelId();
 
   ui_test_utils::NavigateToURL(browser(), chromium_org_url());
   // If the page does ask for it, it isn't empty, even if the background page
   // closes upon receipt of the connect.
   std::string tls_channel_id = GetTlsChannelIdFromPortConnect(
-      chromium_connectable, true, close_background_message());
+      chromium_connectable.get(), true, close_background_message());
   EXPECT_EQ(expected_tls_channel_id_value, tls_channel_id);
   // A subsequent connect will still succeed, even if the background page was
   // previously closed.
-  tls_channel_id = GetTlsChannelIdFromPortConnect(chromium_connectable, true);
+  tls_channel_id =
+      GetTlsChannelIdFromPortConnect(chromium_connectable.get(), true);
    // And the expected value is still retrieved.
   EXPECT_EQ(expected_tls_channel_id_value, tls_channel_id);
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionApiTest, MessagingUserGesture) {
   const char kManifest[] = "{"
                           "  \"name\": \"user_gesture\","
                           "  \"version\": \"1.0\","
                           "  \"background\": {"
                           "    \"scripts\": [\"background.js\"]"
@@ skipping 38 matching lines @@
 
 // Tests that a hosted app on a connectable site doesn't interfere with the
 // connectability of that site.
 IN_PROC_BROWSER_TEST_F(ExternallyConnectableMessagingTest, HostedAppOnWebsite) {
   InitializeTestServer();
 
   scoped_refptr<const Extension> app = LoadChromiumHostedApp();
 
   // The presence of the hosted app shouldn't give the ability to send messages.
   ui_test_utils::NavigateToURL(browser(), chromium_org_url());
-  EXPECT_EQ(NAMESPACE_NOT_DEFINED, CanConnectAndSendMessagesToMainFrame(app));
+  EXPECT_EQ(NAMESPACE_NOT_DEFINED,
+            CanConnectAndSendMessagesToMainFrame(app.get()));
   EXPECT_FALSE(AreAnyNonWebApisDefinedForMainFrame());
 
   // Once a connectable extension is installed, it should.
-  const Extension* extension = LoadChromiumConnectableExtension();
-  EXPECT_EQ(OK, CanConnectAndSendMessagesToMainFrame(extension));
+  scoped_refptr<const Extension> extension = LoadChromiumConnectableExtension();
+  EXPECT_EQ(OK, CanConnectAndSendMessagesToMainFrame(extension.get()));
   EXPECT_FALSE(AreAnyNonWebApisDefinedForMainFrame());
 }
 
 // Tests that an invalid extension ID specified in a hosted app does not crash
 // the hosted app's renderer.
 //
 // This is a regression test for http://crbug.com/326250#c12.
 IN_PROC_BROWSER_TEST_F(ExternallyConnectableMessagingTest,
                        InvalidExtensionIDFromHostedApp) {
   InitializeTestServer();
 
   // The presence of the chromium hosted app triggers this bug. The chromium
   // connectable extension needs to be installed to set up the runtime bindings.
   LoadChromiumHostedApp();
   LoadChromiumConnectableExtension();
 
   scoped_refptr<const Extension> invalid =
       ExtensionBuilder()
           // A bit scary that this works...
           .SetID("invalid")
           .SetManifest(DictionaryBuilder()
                            .Set("name", "Fake extension")
                            .Set("version", "1")
                            .Set("manifest_version", 2))
           .Build();
 
   ui_test_utils::NavigateToURL(browser(), chromium_org_url());
   EXPECT_EQ(COULD_NOT_ESTABLISH_CONNECTION_ERROR,
-            CanConnectAndSendMessagesToMainFrame(invalid));
+            CanConnectAndSendMessagesToMainFrame(invalid.get()));
 }
 
 #endif  // !defined(OS_WIN) - http://crbug.com/350517.
 
 }  // namespace
 
 };  // namespace extensions