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

chrome/browser/background/background_application_list_model_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.
 
 // TODO(rickcam): Bug 73183: Add unit tests for image loading
 
 #include <cstdlib>
 #include <set>
 
 #include "chrome/browser/background/background_application_list_model.h"
@@ skipping 130 matching lines @@
   scoped_refptr<Extension> ext1 = CreateExtension("alpha", false);
   scoped_refptr<Extension> ext2 = CreateExtension("bravo", false);
   scoped_refptr<Extension> ext3 = CreateExtension("charlie", false);
   scoped_refptr<Extension> bgapp1 = CreateExtension("delta", true);
   scoped_refptr<Extension> bgapp2 = CreateExtension("echo", true);
   ASSERT_TRUE(service->extensions() != NULL);
   ASSERT_EQ(0U, service->extensions()->size());
   ASSERT_EQ(0U, model->size());
 
   // Add alternating Extensions and Background Apps
-  ASSERT_FALSE(IsBackgroundApp(*ext1));
-  service->AddExtension(ext1);
+  ASSERT_FALSE(IsBackgroundApp(*ext1.get()));
+  service->AddExtension(ext1.get());
   ASSERT_EQ(1U, service->extensions()->size());
   ASSERT_EQ(0U, model->size());
-  ASSERT_TRUE(IsBackgroundApp(*bgapp1));
-  service->AddExtension(bgapp1);
+  ASSERT_TRUE(IsBackgroundApp(*bgapp1.get()));
+  service->AddExtension(bgapp1.get());
   ASSERT_EQ(2U, service->extensions()->size());
   ASSERT_EQ(1U, model->size());
-  ASSERT_FALSE(IsBackgroundApp(*ext2));
-  service->AddExtension(ext2);
+  ASSERT_FALSE(IsBackgroundApp(*ext2.get()));
+  service->AddExtension(ext2.get());
   ASSERT_EQ(3U, service->extensions()->size());
   ASSERT_EQ(1U, model->size());
-  ASSERT_TRUE(IsBackgroundApp(*bgapp2));
-  service->AddExtension(bgapp2);
+  ASSERT_TRUE(IsBackgroundApp(*bgapp2.get()));
+  service->AddExtension(bgapp2.get());
   ASSERT_EQ(4U, service->extensions()->size());
   ASSERT_EQ(2U, model->size());
-  ASSERT_FALSE(IsBackgroundApp(*ext3));
-  service->AddExtension(ext3);
+  ASSERT_FALSE(IsBackgroundApp(*ext3.get()));
+  service->AddExtension(ext3.get());
   ASSERT_EQ(5U, service->extensions()->size());
   ASSERT_EQ(2U, model->size());
 
   // Remove in FIFO order.
-  ASSERT_FALSE(IsBackgroundApp(*ext1));
+  ASSERT_FALSE(IsBackgroundApp(*ext1.get()));
   service->UninstallExtension(ext1->id(), false, NULL);
   ASSERT_EQ(4U, service->extensions()->size());
   ASSERT_EQ(2U, model->size());
-  ASSERT_TRUE(IsBackgroundApp(*bgapp1));
+  ASSERT_TRUE(IsBackgroundApp(*bgapp1.get()));
   service->UninstallExtension(bgapp1->id(), false, NULL);
   ASSERT_EQ(3U, service->extensions()->size());
   ASSERT_EQ(1U, model->size());
-  ASSERT_FALSE(IsBackgroundApp(*ext2));
+  ASSERT_FALSE(IsBackgroundApp(*ext2.get()));
   service->UninstallExtension(ext2->id(), false, NULL);
   ASSERT_EQ(2U, service->extensions()->size());
   ASSERT_EQ(1U, model->size());
-  ASSERT_TRUE(IsBackgroundApp(*bgapp2));
+  ASSERT_TRUE(IsBackgroundApp(*bgapp2.get()));
   service->UninstallExtension(bgapp2->id(), false, NULL);
   ASSERT_EQ(1U, service->extensions()->size());
   ASSERT_EQ(0U, model->size());
-  ASSERT_FALSE(IsBackgroundApp(*ext3));
+  ASSERT_FALSE(IsBackgroundApp(*ext3.get()));
   service->UninstallExtension(ext3->id(), false, NULL);
   ASSERT_EQ(0U, service->extensions()->size());
   ASSERT_EQ(0U, model->size());
 }
 
 // With minimal test logic, verifies behavior with dynamic permissions.
 TEST_F(BackgroundApplicationListModelTest, AddRemovePermissionsTest) {
   InitializeAndLoadEmptyExtensionService();
   ExtensionService* service = extensions::ExtensionSystem::Get(profile_.get())->
       extension_service();
   ASSERT_TRUE(service);
   ASSERT_TRUE(service->is_ready());
   ASSERT_TRUE(service->extensions());
   ASSERT_TRUE(service->extensions()->is_empty());
   scoped_ptr<BackgroundApplicationListModel> model(
       new BackgroundApplicationListModel(profile_.get()));
   ASSERT_EQ(0U, model->size());
 
   scoped_refptr<Extension> ext = CreateExtension("extension", false);
   ASSERT_FALSE(ext->HasAPIPermission(APIPermission::kBackground));
   scoped_refptr<Extension> bgapp = CreateExtension("application", true);
   ASSERT_TRUE(bgapp->HasAPIPermission(APIPermission::kBackground));
   ASSERT_TRUE(service->extensions() != NULL);
   ASSERT_EQ(0U, service->extensions()->size());
   ASSERT_EQ(0U, model->size());
 
   // Add one (non-background) extension and one background application
-  ASSERT_FALSE(IsBackgroundApp(*ext));
-  service->AddExtension(ext);
+  ASSERT_FALSE(IsBackgroundApp(*ext.get()));
+  service->AddExtension(ext.get());
   ASSERT_EQ(1U, service->extensions()->size());
   ASSERT_EQ(0U, model->size());
-  ASSERT_TRUE(IsBackgroundApp(*bgapp));
-  service->AddExtension(bgapp);
+  ASSERT_TRUE(IsBackgroundApp(*bgapp.get()));
+  service->AddExtension(bgapp.get());
   ASSERT_EQ(2U, service->extensions()->size());
   ASSERT_EQ(1U, model->size());
 
   // Change permissions back and forth
   AddBackgroundPermission(service, ext.get());
   ASSERT_TRUE(ext->HasAPIPermission(APIPermission::kBackground));
   ASSERT_EQ(2U, service->extensions()->size());
   ASSERT_EQ(2U, model->size());
   RemoveBackgroundPermission(service, bgapp.get());
   ASSERT_FALSE(bgapp->HasAPIPermission(APIPermission::kBackground));
@@ skipping 17 matching lines @@
                   BackgroundApplicationListModel* model,
                   size_t* expected,
                   size_t* count) {
   bool create_background = false;
   if (rand() % 2) {
     create_background = true;
     ++*expected;
   }
   scoped_refptr<Extension> extension =
       CreateExtension(GenerateUniqueExtensionName(), create_background);
-  ASSERT_EQ(BackgroundApplicationListModel::IsBackgroundApp(*extension,
+  ASSERT_EQ(BackgroundApplicationListModel::IsBackgroundApp(*extension.get(),
                                                             service->profile()),
             create_background);
   extensions->insert(extension);
   ++*count;
   ASSERT_EQ(*count, extensions->size());
-  service->AddExtension(extension);
+  service->AddExtension(extension.get());
   ASSERT_EQ(*count, service->extensions()->size());
   ASSERT_EQ(*expected, model->size());
 }
 
 void RemoveExtension(ExtensionService* service,
                      ExtensionCollection* extensions,
                      BackgroundApplicationListModel* model,
                      size_t* expected,
                      size_t* count) {  // Maybe remove an extension.
   ExtensionCollection::iterator cursor = extensions->begin();
   if (cursor == extensions->end()) {
     // Nothing to remove.  Just verify accounting.
     ASSERT_EQ(0U, *count);
     ASSERT_EQ(0U, *expected);
     ASSERT_EQ(0U, service->extensions()->size());
     ASSERT_EQ(0U, model->size());
   } else {
     // Randomly select which extension to remove
     if (extensions->size() > 1) {
       int offset = rand() % (extensions->size() - 1);
       for (int index = 0; index < offset; ++index)
         ++cursor;
     }
     scoped_refptr<Extension> extension = cursor->get();
     std::string id = extension->id();
-    if (BackgroundApplicationListModel::IsBackgroundApp(*extension,
+    if (BackgroundApplicationListModel::IsBackgroundApp(*extension.get(),
                                                         service->profile())) {
       --*expected;
     }
     extensions->erase(cursor);
     --*count;
     ASSERT_EQ(*count, extensions->size());
     service->UninstallExtension(extension->id(), false, NULL);
     ASSERT_EQ(*count, service->extensions()->size());
     ASSERT_EQ(*expected, model->size());
   }
@@ skipping 13 matching lines @@
     ASSERT_EQ(0U, model->size());
   } else {
     // Randomly select which extension to toggle.
     if (extensions->size() > 1) {
       int offset = rand() % (extensions->size() - 1);
       for (int index = 0; index < offset; ++index)
         ++cursor;
     }
     scoped_refptr<Extension> extension = cursor->get();
     std::string id = extension->id();
-    if (BackgroundApplicationListModel::IsBackgroundApp(*extension,
+    if (BackgroundApplicationListModel::IsBackgroundApp(*extension.get(),
                                                         service->profile())) {
       --*expected;
       ASSERT_EQ(*count, extensions->size());
-      RemoveBackgroundPermission(service, extension);
+      RemoveBackgroundPermission(service, extension.get());
       ASSERT_EQ(*count, service->extensions()->size());
       ASSERT_EQ(*expected, model->size());
     } else {
       ++*expected;
       ASSERT_EQ(*count, extensions->size());
-      AddBackgroundPermission(service, extension);
+      AddBackgroundPermission(service, extension.get());
       ASSERT_EQ(*count, service->extensions()->size());
       ASSERT_EQ(*expected, model->size());
     }
   }
 }
 }  // namespace
 
 // Verifies behavior with a pseudo-randomly generated set of actions: Adding and
 // removing extensions, of which some are Background Apps and others are not.
 TEST_F(BackgroundApplicationListModelTest, RandomTest) {
@@ skipping 23 matching lines @@
         break;
       case 2:
         TogglePermission(service, &extensions, model.get(), &expected, &count);
         break;
       default:
         NOTREACHED();
         break;
     }
   }
 }