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

chrome/browser/extensions/extension_special_storage_policy_unittest.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/message_loop.h"
 #include "base/values.h"
 #include "chrome/browser/content_settings/cookie_settings.h"
 #include "chrome/browser/extensions/extension_special_storage_policy.h"
 #include "chrome/common/content_settings.h"
 #include "chrome/common/content_settings_types.h"
@@ skipping 178 matching lines @@
   ExtensionSet empty_set;
   ExpectProtectedBy(empty_set, kHttpUrl);
 
   // This one is just based on the scheme.
   EXPECT_TRUE(policy_->IsStorageProtected(kExtensionUrl));
   EXPECT_TRUE(policy_->IsStorageProtected(app->url()));
 }
 
 TEST_F(ExtensionSpecialStoragePolicyTest, AppWithProtectedStorage) {
   scoped_refptr<Extension> extension(CreateProtectedApp());
-  policy_->GrantRightsForExtension(extension);
+  policy_->GrantRightsForExtension(extension.get());
   ExtensionSet protecting_extensions;
   protecting_extensions.Insert(extension);
   ExtensionSet empty_set;
 
   EXPECT_FALSE(policy_->IsStorageUnlimited(extension->url()));
   EXPECT_FALSE(policy_->IsStorageUnlimited(GURL("http://explicit/")));
   ExpectProtectedBy(protecting_extensions, GURL("http://explicit/"));
   ExpectProtectedBy(protecting_extensions, GURL("http://explicit:6000/"));
   ExpectProtectedBy(protecting_extensions, GURL("http://foo.wildcards/"));
   ExpectProtectedBy(protecting_extensions, GURL("https://bar.wildcards/"));
   ExpectProtectedBy(empty_set, GURL("http://not_listed/"));
 
-  policy_->RevokeRightsForExtension(extension);
+  policy_->RevokeRightsForExtension(extension.get());
   ExpectProtectedBy(empty_set, GURL("http://explicit/"));
   ExpectProtectedBy(empty_set, GURL("http://foo.wildcards/"));
   ExpectProtectedBy(empty_set, GURL("https://bar.wildcards/"));
 }
 
 TEST_F(ExtensionSpecialStoragePolicyTest, AppWithUnlimitedStorage) {
   scoped_refptr<Extension> extension(CreateUnlimitedApp());
-  policy_->GrantRightsForExtension(extension);
+  policy_->GrantRightsForExtension(extension.get());
   ExtensionSet protecting_extensions;
   protecting_extensions.Insert(extension);
   ExtensionSet empty_set;
 
   ExpectProtectedBy(protecting_extensions, GURL("http://explicit/"));
   ExpectProtectedBy(protecting_extensions, GURL("http://explicit:6000/"));
   ExpectProtectedBy(protecting_extensions, GURL("https://foo.wildcards/"));
   ExpectProtectedBy(protecting_extensions, GURL("https://foo.wildcards/"));
   ExpectProtectedBy(protecting_extensions, GURL("http://bar.wildcards/"));
   ExpectProtectedBy(empty_set, GURL("http://not_listed/"));
   EXPECT_TRUE(policy_->IsStorageUnlimited(extension->url()));
   EXPECT_TRUE(policy_->IsStorageUnlimited(GURL("http://explicit/")));
   EXPECT_TRUE(policy_->IsStorageUnlimited(GURL("http://explicit:6000/")));
   EXPECT_TRUE(policy_->IsStorageUnlimited(GURL("https://foo.wildcards/")));
   EXPECT_TRUE(policy_->IsStorageUnlimited(GURL("https://bar.wildcards/")));
   EXPECT_FALSE(policy_->IsStorageUnlimited(GURL("http://not_listed/")));
 
-  policy_->RevokeRightsForExtension(extension);
+  policy_->RevokeRightsForExtension(extension.get());
   ExpectProtectedBy(empty_set, GURL("http://explicit/"));
   ExpectProtectedBy(empty_set, GURL("https://foo.wildcards/"));
   ExpectProtectedBy(empty_set, GURL("https://foo.wildcards/"));
   ExpectProtectedBy(empty_set, GURL("http://bar.wildcards/"));
   EXPECT_FALSE(policy_->IsStorageUnlimited(GURL("http://explicit/")));
   EXPECT_FALSE(policy_->IsStorageUnlimited(GURL("https://foo.wildcards/")));
   EXPECT_FALSE(policy_->IsStorageUnlimited(GURL("https://bar.wildcards/")));
 }
 
 TEST_F(ExtensionSpecialStoragePolicyTest, CanQueryDiskSize) {
   const GURL kHttpUrl("http://foo");
   const GURL kExtensionUrl("chrome-extension://bar");
   scoped_refptr<Extension> regular_app(CreateRegularApp());
   scoped_refptr<Extension> protected_app(CreateProtectedApp());
   scoped_refptr<Extension> unlimited_app(CreateUnlimitedApp());
-  policy_->GrantRightsForExtension(regular_app);
-  policy_->GrantRightsForExtension(protected_app);
-  policy_->GrantRightsForExtension(unlimited_app);
+  policy_->GrantRightsForExtension(regular_app.get());
+  policy_->GrantRightsForExtension(protected_app.get());
+  policy_->GrantRightsForExtension(unlimited_app.get());
 
   EXPECT_FALSE(policy_->CanQueryDiskSize(kHttpUrl));
   EXPECT_FALSE(policy_->CanQueryDiskSize(kExtensionUrl));
   EXPECT_TRUE(policy_->CanQueryDiskSize(regular_app->url()));
   EXPECT_TRUE(policy_->CanQueryDiskSize(protected_app->url()));
   EXPECT_TRUE(policy_->CanQueryDiskSize(unlimited_app->url()));
 }
 
 TEST_F(ExtensionSpecialStoragePolicyTest, HasIsolatedStorage) {
   const GURL kHttpUrl("http://foo");
   const GURL kExtensionUrl("chrome-extension://bar");
   scoped_refptr<Extension> app(CreateRegularApp());
-  policy_->GrantRightsForExtension(app);
+  policy_->GrantRightsForExtension(app.get());
 
   EXPECT_FALSE(policy_->HasIsolatedStorage(kHttpUrl));
   EXPECT_FALSE(policy_->HasIsolatedStorage(kExtensionUrl));
   EXPECT_TRUE(policy_->HasIsolatedStorage(app->url()));
 }
 
 TEST_F(ExtensionSpecialStoragePolicyTest, OverlappingApps) {
   scoped_refptr<Extension> protected_app(CreateProtectedApp());
   scoped_refptr<Extension> unlimited_app(CreateUnlimitedApp());
-  policy_->GrantRightsForExtension(protected_app);
-  policy_->GrantRightsForExtension(unlimited_app);
+  policy_->GrantRightsForExtension(protected_app.get());
+  policy_->GrantRightsForExtension(unlimited_app.get());
   ExtensionSet protecting_extensions;
   ExtensionSet empty_set;
   protecting_extensions.Insert(protected_app);
   protecting_extensions.Insert(unlimited_app);
 
   ExpectProtectedBy(protecting_extensions, GURL("http://explicit/"));
   ExpectProtectedBy(protecting_extensions, GURL("http://explicit:6000/"));
   ExpectProtectedBy(protecting_extensions, GURL("https://foo.wildcards/"));
   ExpectProtectedBy(protecting_extensions, GURL("https://foo.wildcards/"));
   ExpectProtectedBy(protecting_extensions, GURL("http://bar.wildcards/"));
   ExpectProtectedBy(empty_set, GURL("http://not_listed/"));
   EXPECT_TRUE(policy_->IsStorageUnlimited(GURL("http://explicit/")));
   EXPECT_TRUE(policy_->IsStorageUnlimited(GURL("http://explicit:6000/")));
   EXPECT_TRUE(policy_->IsStorageUnlimited(GURL("https://foo.wildcards/")));
   EXPECT_TRUE(policy_->IsStorageUnlimited(GURL("https://bar.wildcards/")));
   EXPECT_FALSE(policy_->IsStorageUnlimited(GURL("http://not_listed/")));
 
-  policy_->RevokeRightsForExtension(unlimited_app);
+  policy_->RevokeRightsForExtension(unlimited_app.get());
   protecting_extensions.Remove(unlimited_app->id());
   EXPECT_FALSE(policy_->IsStorageUnlimited(GURL("http://explicit/")));
   EXPECT_FALSE(policy_->IsStorageUnlimited(GURL("https://foo.wildcards/")));
   EXPECT_FALSE(policy_->IsStorageUnlimited(GURL("https://bar.wildcards/")));
   ExpectProtectedBy(protecting_extensions, GURL("http://explicit/"));
   ExpectProtectedBy(protecting_extensions, GURL("http://foo.wildcards/"));
   ExpectProtectedBy(protecting_extensions, GURL("https://bar.wildcards/"));
 
-  policy_->RevokeRightsForExtension(protected_app);
+  policy_->RevokeRightsForExtension(protected_app.get());
   ExpectProtectedBy(empty_set, GURL("http://explicit/"));
   ExpectProtectedBy(empty_set, GURL("http://foo.wildcards/"));
   ExpectProtectedBy(empty_set, GURL("https://bar.wildcards/"));
 }
 
 TEST_F(ExtensionSpecialStoragePolicyTest, HasSessionOnlyOrigins) {
   base::MessageLoop message_loop;
   content::TestBrowserThread ui_thread(BrowserThread::UI, &message_loop);
 
   TestingProfile profile;
@@ skipping 44 matching lines @@
     SpecialStoragePolicy::STORAGE_PROTECTED,
 
     SpecialStoragePolicy::STORAGE_PROTECTED |
     SpecialStoragePolicy::STORAGE_UNLIMITED,
   };
 
   ASSERT_EQ(arraysize(apps), arraysize(change_flags));
   for (size_t i = 0; i < arraysize(apps); ++i) {
     SCOPED_TRACE(testing::Message() << "i: " << i);
     observer.ExpectGrant(apps[i]->id(), change_flags[i]);
-    policy_->GrantRightsForExtension(apps[i]);
+    policy_->GrantRightsForExtension(apps[i].get());
     message_loop.RunUntilIdle();
     EXPECT_TRUE(observer.IsCompleted());
   }
 
   for (size_t i = 0; i < arraysize(apps); ++i) {
     SCOPED_TRACE(testing::Message() << "i: " << i);
-    policy_->GrantRightsForExtension(apps[i]);
+    policy_->GrantRightsForExtension(apps[i].get());
     message_loop.RunUntilIdle();
     EXPECT_TRUE(observer.IsCompleted());
   }
 
   for (size_t i = 0; i < arraysize(apps); ++i) {
     SCOPED_TRACE(testing::Message() << "i: " << i);
     observer.ExpectRevoke(apps[i]->id(), change_flags[i]);
-    policy_->RevokeRightsForExtension(apps[i]);
+    policy_->RevokeRightsForExtension(apps[i].get());
     message_loop.RunUntilIdle();
     EXPECT_TRUE(observer.IsCompleted());
   }
 
   for (size_t i = 0; i < arraysize(apps); ++i) {
     SCOPED_TRACE(testing::Message() << "i: " << i);
-    policy_->RevokeRightsForExtension(apps[i]);
+    policy_->RevokeRightsForExtension(apps[i].get());
     message_loop.RunUntilIdle();
     EXPECT_TRUE(observer.IsCompleted());
   }
 
   observer.ExpectClear();
   policy_->RevokeRightsForAllExtensions();
   message_loop.RunUntilIdle();
   EXPECT_TRUE(observer.IsCompleted());
 
   policy_->RemoveObserver(&observer);
 }