cc: Remove use of PassAs() and constructor-casting with scoped_ptr.

cc/resources/prioritized_resource_unittest.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 "cc/resources/prioritized_resource.h"
 
 #include <vector>
 
 #include "cc/resources/prioritized_resource_manager.h"
 #include "cc/resources/resource.h"
@@ skipping 21 matching lines @@
                                                   shared_bitmap_manager_.get(),
                                                   NULL,
                                                   0,
                                                   false,
                                                   1,
                                                   false);
   }
 
   virtual ~PrioritizedResourceTest() {
     DebugScopedSetImplThread impl_thread(&proxy_);
-    resource_provider_.reset();
+    resource_provider_ = nullptr;
   }
 
   size_t TexturesMemorySize(size_t texture_count) {
     return Resource::MemorySizeBytes(texture_size_, texture_format_) *
            texture_count;
   }
 
   scoped_ptr<PrioritizedResourceManager> CreateManager(size_t max_textures) {
     scoped_ptr<PrioritizedResourceManager> manager =
         PrioritizedResourceManager::Create(&proxy_);
@@ skipping 217 matching lines @@
   {
     DebugScopedSetImplThreadAndMainThreadBlocked
         impl_thread_and_main_thread_blocked(&proxy_);
     resource_manager->ReduceMemory(resource_provider());
   }
 
   // 20 textures have backings allocated.
   EXPECT_EQ(TexturesMemorySize(20), resource_manager->MemoryUseBytes());
 
   // Destroy one texture, not enough is wasted to cause cleanup.
-  textures[0] = scoped_ptr<PrioritizedResource>();
+  textures[0] = nullptr;
   PrioritizeTexturesAndBackings(resource_manager.get());
   {
     DebugScopedSetImplThreadAndMainThreadBlocked
         impl_thread_and_main_thread_blocked(&proxy_);
     resource_manager->UpdateBackingsState(resource_provider());
     resource_manager->ReduceWastedMemory(resource_provider());
   }
   EXPECT_EQ(TexturesMemorySize(20), resource_manager->MemoryUseBytes());
 
   // Destroy half the textures, leaving behind the backings. Now a cleanup
   // should happen.
   for (size_t i = 0; i < kMaxTextures / 2; ++i)
-    textures[i] = scoped_ptr<PrioritizedResource>();
+    textures[i] = nullptr;
   PrioritizeTexturesAndBackings(resource_manager.get());
   {
     DebugScopedSetImplThreadAndMainThreadBlocked
         impl_thread_and_main_thread_blocked(&proxy_);
     resource_manager->UpdateBackingsState(resource_provider());
     resource_manager->ReduceWastedMemory(resource_provider());
   }
   EXPECT_GT(TexturesMemorySize(20), resource_manager->MemoryUseBytes());
 
   DebugScopedSetImplThreadAndMainThreadBlocked
@@ skipping 46 matching lines @@
   ResourceProvider::ResourceIdArray to_send;
   TransferableResourceArray transferable;
   for (size_t i = 0; i < kMaxTextures / 2; ++i)
     to_send.push_back(textures[i]->resource_id());
   resource_provider_->PrepareSendToParent(to_send, &transferable);
 
   // Destroy half the textures, leaving behind the backings. The backings are
   // sent to a parent compositor though, so they should not be considered wasted
   // and a cleanup should not happen.
   for (size_t i = 0; i < kMaxTextures / 2; ++i)
-    textures[i] = scoped_ptr<PrioritizedResource>();
+    textures[i] = nullptr;
   PrioritizeTexturesAndBackings(resource_manager.get());
   {
     DebugScopedSetImplThreadAndMainThreadBlocked
         impl_thread_and_main_thread_blocked(&proxy_);
     resource_manager->UpdateBackingsState(resource_provider());
     resource_manager->ReduceWastedMemory(resource_provider());
   }
   EXPECT_EQ(TexturesMemorySize(20), resource_manager->MemoryUseBytes());
 
   // Receive the textures back from the parent compositor. Now a cleanup should
@@ skipping 187 matching lines @@
   textures[4]->set_request_priority(100 + 4);
   textures[5]->set_request_priority(100 + 5);
   textures[6]->set_request_priority(100 + 4);
   textures[7]->set_request_priority(100 + 5);
 
   for (size_t i = 0; i < 8; ++i)
     texture_resource_ids[i] = textures[i]->resource_id();
 
   // Drop all the textures. Now we have backings that can be recycled.
   for (size_t i = 0; i < 8; ++i)
-    textures[0].reset();
+    textures[0] = nullptr;
   PrioritizeTexturesAndBackings(resource_manager.get());
 
   // The next commit finishes.
   {
     DebugScopedSetImplThreadAndMainThreadBlocked
         impl_thread_and_main_thread_blocked(&proxy_);
     resource_manager->UpdateBackingsState(resource_provider());
   }
 
   // Evict four textures. It would be the last four again, except that 2 of them
@@ skipping 142 matching lines @@
   PrioritizeTexturesAndBackings(resource_manager.get());
 
   EXPECT_TRUE(ValidateTexture(texture.get(), false));
   EXPECT_TRUE(texture->can_acquire_backing_texture());
   EXPECT_TRUE(texture->have_backing_texture());
   {
     DebugScopedSetImplThreadAndMainThreadBlocked
         impl_thread_and_main_thread_blocked(&proxy_);
     resource_manager->ClearAllMemory(resource_provider());
   }
-  resource_manager.reset();
+  resource_manager = nullptr;
 
   EXPECT_FALSE(texture->can_acquire_backing_texture());
   EXPECT_FALSE(texture->have_backing_texture());
 }
 
 TEST_F(PrioritizedResourceTest, TextureMovedToNewManager) {
   scoped_ptr<PrioritizedResourceManager> resource_manager_one =
       CreateManager(1);
   scoped_ptr<PrioritizedResourceManager> resource_manager_two =
       CreateManager(1);
   scoped_ptr<PrioritizedResource> texture =
       resource_manager_one->CreateTexture(texture_size_, texture_format_);
 
   // Texture is initially invalid, but it will become available.
   EXPECT_FALSE(texture->have_backing_texture());
 
   texture->set_request_priority(100);
   PrioritizeTexturesAndBackings(resource_manager_one.get());
 
   EXPECT_TRUE(ValidateTexture(texture.get(), false));
   EXPECT_TRUE(texture->can_acquire_backing_texture());
   EXPECT_TRUE(texture->have_backing_texture());
 
   texture->SetTextureManager(NULL);
   {
     DebugScopedSetImplThreadAndMainThreadBlocked
         impl_thread_and_main_thread_blocked(&proxy_);
     resource_manager_one->ClearAllMemory(resource_provider());
   }
-  resource_manager_one.reset();
+  resource_manager_one = nullptr;
 
   EXPECT_FALSE(texture->can_acquire_backing_texture());
   EXPECT_FALSE(texture->have_backing_texture());
 
   texture->SetTextureManager(resource_manager_two.get());
 
   PrioritizeTexturesAndBackings(resource_manager_two.get());
 
   EXPECT_TRUE(ValidateTexture(texture.get(), false));
   EXPECT_TRUE(texture->can_acquire_backing_texture());
@@ skipping 336 matching lines @@
               resource_manager->MemoryVisibleAndNearbyBytes());
   }
 
   DebugScopedSetImplThreadAndMainThreadBlocked
       impl_thread_and_main_thread_blocked(&proxy_);
   resource_manager->ClearAllMemory(resource_provider());
 }
 
 }  // namespace
 }  // namespace cc