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

chrome/browser/extensions/extension_blacklist_browsertest.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 "base/run_loop.h"
 #include "base/stringprintf.h"
 #include "chrome/browser/extensions/blacklist.h"
 #include "chrome/browser/extensions/extension_browsertest.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
@@ skipping 242 matching lines @@
       InstallExtension(test_data_dir_.AppendASCII(info_c_.path()), 1);
 
   EXPECT_TRUE(notifications.CheckNotifications(
       chrome::NOTIFICATION_EXTENSION_INSTALLED,
       chrome::NOTIFICATION_EXTENSION_LOADED,
       chrome::NOTIFICATION_EXTENSION_INSTALLED,
       chrome::NOTIFICATION_EXTENSION_LOADED,
       chrome::NOTIFICATION_EXTENSION_INSTALLED,
       chrome::NOTIFICATION_EXTENSION_LOADED));
 
-  ASSERT_TRUE(extension_a);
-  ASSERT_TRUE(extension_b);
+  ASSERT_TRUE(extension_a.get());
+  ASSERT_TRUE(extension_b.get());
   ASSERT_EQ(info_a_.id(), extension_a->id());
   ASSERT_EQ(info_b_.id(), extension_b->id());
   ASSERT_EQ(info_c_.id(), extension_c->id());
 
   std::vector<std::string> empty_vector;
   std::vector<std::string> vector_a(1, info_a_.id());
   std::vector<std::string> vector_b(1, info_b_.id());
   std::vector<std::string> vector_c(1, info_c_.id());
   std::vector<std::string> vector_ab(1, info_a_.id());
   vector_ab.push_back(info_b_.id());
   std::vector<std::string> vector_bc(1, info_b_.id());
   vector_bc.push_back(info_c_.id());
   std::vector<std::string> vector_abc(1, info_a_.id());
   vector_abc.push_back(info_b_.id());
   vector_abc.push_back(info_c_.id());
 
-  EXPECT_TRUE(IsSafe(extension_a));
-  EXPECT_TRUE(IsSafe(extension_b));
-  EXPECT_TRUE(IsSafe(extension_c));
+  EXPECT_TRUE(IsSafe(extension_a.get()));
+  EXPECT_TRUE(IsSafe(extension_b.get()));
+  EXPECT_TRUE(IsSafe(extension_c.get()));
 
   // Blacklist a and b.
   blacklist()->SetFromUpdater(vector_ab, "1");
   base::RunLoop().RunUntilIdle();
 
-  EXPECT_TRUE(IsBlacklisted(extension_a));
-  EXPECT_TRUE(IsBlacklisted(extension_b));
-  EXPECT_TRUE(IsSafe(extension_c));
+  EXPECT_TRUE(IsBlacklisted(extension_a.get()));
+  EXPECT_TRUE(IsBlacklisted(extension_b.get()));
+  EXPECT_TRUE(IsSafe(extension_c.get()));
   EXPECT_TRUE(notifications.CheckNotifications(
       chrome::NOTIFICATION_EXTENSION_UNLOADED,
       chrome::NOTIFICATION_EXTENSION_UNLOADED));
 
   // Un-blacklist a.
   blacklist()->SetFromUpdater(vector_b, "2");
   base::RunLoop().RunUntilIdle();
 
-  EXPECT_TRUE(IsSafe(extension_a));
-  EXPECT_TRUE(IsBlacklisted(extension_b));
-  EXPECT_TRUE(IsSafe(extension_c));
-  EXPECT_TRUE(notifications.CheckNotifications(
-      chrome::NOTIFICATION_EXTENSION_LOADED));
+  EXPECT_TRUE(IsSafe(extension_a.get()));
+  EXPECT_TRUE(IsBlacklisted(extension_b.get()));
+  EXPECT_TRUE(IsSafe(extension_c.get()));
+  EXPECT_TRUE(
+      notifications.CheckNotifications(chrome::NOTIFICATION_EXTENSION_LOADED));
 
   // Blacklist a then switch with c.
   blacklist()->SetFromUpdater(vector_ab, "3");
   base::RunLoop().RunUntilIdle();
 
-  EXPECT_TRUE(IsBlacklisted(extension_a));
-  EXPECT_TRUE(IsBlacklisted(extension_b));
-  EXPECT_TRUE(IsSafe(extension_c));
+  EXPECT_TRUE(IsBlacklisted(extension_a.get()));
+  EXPECT_TRUE(IsBlacklisted(extension_b.get()));
+  EXPECT_TRUE(IsSafe(extension_c.get()));
   EXPECT_TRUE(notifications.CheckNotifications(
       chrome::NOTIFICATION_EXTENSION_UNLOADED));
 
   blacklist()->SetFromUpdater(vector_bc, "4");
   base::RunLoop().RunUntilIdle();
 
-  EXPECT_TRUE(IsSafe(extension_a));
-  EXPECT_TRUE(IsBlacklisted(extension_b));
-  EXPECT_TRUE(IsBlacklisted(extension_c));
+  EXPECT_TRUE(IsSafe(extension_a.get()));
+  EXPECT_TRUE(IsBlacklisted(extension_b.get()));
+  EXPECT_TRUE(IsBlacklisted(extension_c.get()));
   EXPECT_TRUE(notifications.CheckNotifications(
       chrome::NOTIFICATION_EXTENSION_LOADED,
       chrome::NOTIFICATION_EXTENSION_UNLOADED));
 
   // Add a to blacklist.
   blacklist()->SetFromUpdater(vector_abc, "5");
   base::RunLoop().RunUntilIdle();
 
-  EXPECT_TRUE(IsBlacklisted(extension_a));
-  EXPECT_TRUE(IsBlacklisted(extension_b));
-  EXPECT_TRUE(IsBlacklisted(extension_c));
+  EXPECT_TRUE(IsBlacklisted(extension_a.get()));
+  EXPECT_TRUE(IsBlacklisted(extension_b.get()));
+  EXPECT_TRUE(IsBlacklisted(extension_c.get()));
   EXPECT_TRUE(notifications.CheckNotifications(
       chrome::NOTIFICATION_EXTENSION_UNLOADED));
 
   // Clear blacklist.
   blacklist()->SetFromUpdater(empty_vector, "6");
   base::RunLoop().RunUntilIdle();
 
-  EXPECT_TRUE(IsSafe(extension_a));
-  EXPECT_TRUE(IsSafe(extension_b));
-  EXPECT_TRUE(IsSafe(extension_c));
-  EXPECT_TRUE(notifications.CheckNotifications(
-      chrome::NOTIFICATION_EXTENSION_LOADED,
-      chrome::NOTIFICATION_EXTENSION_LOADED,
-      chrome::NOTIFICATION_EXTENSION_LOADED));
+  EXPECT_TRUE(IsSafe(extension_a.get()));
+  EXPECT_TRUE(IsSafe(extension_b.get()));
+  EXPECT_TRUE(IsSafe(extension_c.get()));
+  EXPECT_TRUE(
+      notifications.CheckNotifications(chrome::NOTIFICATION_EXTENSION_LOADED,
+                                       chrome::NOTIFICATION_EXTENSION_LOADED,
+                                       chrome::NOTIFICATION_EXTENSION_LOADED));
 
   // Add a and b back again for the next test.
   blacklist()->SetFromUpdater(vector_ab, "7");
   base::RunLoop().RunUntilIdle();
 
-  EXPECT_TRUE(IsBlacklisted(extension_a));
-  EXPECT_TRUE(IsBlacklisted(extension_b));
-  EXPECT_TRUE(IsSafe(extension_c));
+  EXPECT_TRUE(IsBlacklisted(extension_a.get()));
+  EXPECT_TRUE(IsBlacklisted(extension_b.get()));
+  EXPECT_TRUE(IsSafe(extension_c.get()));
   EXPECT_TRUE(notifications.CheckNotifications(
       chrome::NOTIFICATION_EXTENSION_UNLOADED,
       chrome::NOTIFICATION_EXTENSION_UNLOADED));
 }
 
 // Stage 2: blacklisting with extensions A and B having been installed,
 // with A actually in the blacklist.
 IN_PROC_BROWSER_TEST_F(ExtensionBlacklistBrowserTest, Blacklist) {
   FilteringNotificationObserver notifications(
       content::Source<Profile>(profile()), GetTestExtensionIDs());
 
   scoped_refptr<const Extension> extension_a =
       extension_service()->blacklisted_extensions()->GetByID(info_a_.id());
-  ASSERT_TRUE(extension_a);
+  ASSERT_TRUE(extension_a.get());
 
   scoped_refptr<const Extension> extension_b =
       extension_service()->blacklisted_extensions()->GetByID(info_b_.id());
-  ASSERT_TRUE(extension_b);
+  ASSERT_TRUE(extension_b.get());
 
   scoped_refptr<const Extension> extension_c =
       extension_service()->extensions()->GetByID(info_c_.id());
-  ASSERT_TRUE(extension_c);
+  ASSERT_TRUE(extension_c.get());
 
-  EXPECT_TRUE(IsBlacklisted(extension_a));
-  EXPECT_TRUE(IsBlacklisted(extension_b));
-  EXPECT_TRUE(IsSafe(extension_c));
+  EXPECT_TRUE(IsBlacklisted(extension_a.get()));
+  EXPECT_TRUE(IsBlacklisted(extension_b.get()));
+  EXPECT_TRUE(IsSafe(extension_c.get()));
 
   // Make sure that we can still blacklist c and unblacklist b.
   std::vector<std::string> vector_ac(1, extension_a->id());
   vector_ac.push_back(extension_c->id());
   blacklist()->SetFromUpdater(vector_ac, "8");
   base::RunLoop().RunUntilIdle();
 
-  EXPECT_TRUE(IsBlacklisted(extension_a));
-  EXPECT_TRUE(IsSafe(extension_b));
-  EXPECT_TRUE(IsBlacklisted(extension_c));
+  EXPECT_TRUE(IsBlacklisted(extension_a.get()));
+  EXPECT_TRUE(IsSafe(extension_b.get()));
+  EXPECT_TRUE(IsBlacklisted(extension_c.get()));
   EXPECT_TRUE(notifications.CheckNotifications(
-        chrome::NOTIFICATION_EXTENSION_LOADED,
-        chrome::NOTIFICATION_EXTENSION_UNLOADED));
+      chrome::NOTIFICATION_EXTENSION_LOADED,
+      chrome::NOTIFICATION_EXTENSION_UNLOADED));
 }
 
 }  // namespace extensions