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

cc/trees/layer_tree_host_unittest_context.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/trees/layer_tree_host.h"
 
 #include "base/basictypes.h"
 #include "cc/layers/content_layer.h"
 #include "cc/layers/delegated_frame_provider.h"
 #include "cc/layers/delegated_frame_resource_collection.h"
@@ skipping 68 matching lines @@
 
   virtual scoped_ptr<TestWebGraphicsContext3D> CreateContext3d() {
     return TestWebGraphicsContext3D::Create();
   }
 
   virtual scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface(bool fallback)
       OVERRIDE {
     if (times_to_fail_create_) {
       --times_to_fail_create_;
       ExpectCreateToFail();
-      return scoped_ptr<FakeOutputSurface>();
+      return nullptr;
     }
 
     scoped_ptr<TestWebGraphicsContext3D> context3d = CreateContext3d();
     context3d_ = context3d.get();
 
     if (context_should_support_io_surface_) {
       context3d_->set_have_extension_io_surface(true);
       context3d_->set_have_extension_egl_image(true);
     }
 
@@ skipping 256 matching lines @@
   }
 
   virtual void BeginTest() OVERRIDE {
     PostSetNeedsCommitToMainThread();
     EndTest();
   }
 
   virtual scoped_ptr<OutputSurface> CreateOutputSurface(bool fallback)
       OVERRIDE {
     EXPECT_TRUE(false);
-    return scoped_ptr<OutputSurface>();
+    return nullptr;
   }
 
   virtual void DidInitializeOutputSurface() OVERRIDE { EXPECT_TRUE(false); }
 
   virtual void AfterTest() OVERRIDE {
   }
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostClientNotReadyDoesNotCreateOutputSurface);
@@ skipping 494 matching lines @@
         gfx::Transform());
 
     scoped_ptr<TestRenderPass> pass = TestRenderPass::Create();
     pass->SetNew(RenderPassId(1, 1),
                  gfx::Rect(0, 0, 10, 10),
                  gfx::Rect(0, 0, 10, 10),
                  gfx::Transform());
     pass->AppendOneOfEveryQuadType(child_resource_provider_.get(),
                                    RenderPassId(2, 1));
 
-    frame_data->render_pass_list.push_back(pass_for_quad.PassAs<RenderPass>());
-    frame_data->render_pass_list.push_back(pass.PassAs<RenderPass>());
+    frame_data->render_pass_list.push_back(pass_for_quad.Pass());
+    frame_data->render_pass_list.push_back(pass.Pass());
 
     delegated_resource_collection_ = new DelegatedFrameResourceCollection;
     delegated_frame_provider_ = new DelegatedFrameProvider(
         delegated_resource_collection_.get(), frame_data.Pass());
 
     ResourceProvider::ResourceId resource =
         child_resource_provider_->CreateResource(
             gfx::Size(4, 4),
             GL_CLAMP_TO_EDGE,
             ResourceProvider::TextureHintImmutable,
@@ skipping 356 matching lines @@
     EXPECT_TRUE(layer_tree_host()->proxy()->IsMainThread());
     switch (step) {
       case 0:
         ui_resource_ = FakeScopedUIResource::Create(layer_tree_host());
         // Expects a valid UIResourceId.
         EXPECT_NE(0, ui_resource_->id());
         PostSetNeedsCommitToMainThread();
         break;
       case 4:
         // Release resource before ending the test.
-        ui_resource_.reset();
+        ui_resource_ = nullptr;
         EndTest();
         break;
       case 5:
         NOTREACHED();
         break;
     }
   }
 
   virtual void StepCompleteOnImplThread(LayerTreeHostImpl* impl) OVERRIDE {
     LayerTreeHostContextTest::CommitCompleteOnThread(impl);
@@ skipping 39 matching lines @@
       case 0:
         ui_resource_ = FakeScopedUIResource::Create(layer_tree_host());
         // Lose the context on the impl thread before the commit.
         PostLoseContextToImplThread();
         break;
       case 2:
         // Sequence 2:
         // Currently one resource has been created.
         test_id0_ = ui_resource_->id();
         // Delete this resource.
-        ui_resource_.reset();
+        ui_resource_ = nullptr;
         // Create another resource.
         ui_resource_ = FakeScopedUIResource::Create(layer_tree_host());
         test_id1_ = ui_resource_->id();
         // Sanity check that two resource creations return different ids.
         EXPECT_NE(test_id0_, test_id1_);
         // Lose the context on the impl thread before the commit.
         PostLoseContextToImplThread();
         break;
       case 3:
         // Clear the manager of resources.
-        ui_resource_.reset();
+        ui_resource_ = nullptr;
         PostSetNeedsCommitToMainThread();
         break;
       case 4:
         // Sequence 3:
         ui_resource_ = FakeScopedUIResource::Create(layer_tree_host());
         test_id0_ = ui_resource_->id();
         // Sanity check the UIResourceId should not be 0.
         EXPECT_NE(0, test_id0_);
         // Usually ScopedUIResource are deleted from the manager in their
-        // destructor (so usually ui_resource_.reset()).  But here we need
+        // destructor (so usually ui_resource_ = nullptr).  But here we need
         // ui_resource_ for the next step, so call DeleteUIResource directly.
         layer_tree_host()->DeleteUIResource(test_id0_);
         // Delete the resouce and then lose the context.
         PostLoseContextToImplThread();
         break;
       case 5:
         // Release resource before ending the test.
-        ui_resource_.reset();
+        ui_resource_ = nullptr;
         EndTest();
         break;
       case 6:
         NOTREACHED();
         break;
     }
   }
 
   virtual void StepCompleteOnImplThread(LayerTreeHostImpl* impl) OVERRIDE {
     LayerTreeHostContextTest::CommitCompleteOnThread(impl);
@@ skipping 43 matching lines @@
 class UIResourceLostBeforeActivateTree : public UIResourceLostTest {
   virtual void StepCompleteOnMainThread(int step) OVERRIDE {
     EXPECT_TRUE(layer_tree_host()->proxy()->IsMainThread());
     switch (step) {
       case 0:
         ui_resource_ = FakeScopedUIResource::Create(layer_tree_host());
         PostSetNeedsCommitToMainThread();
         break;
       case 3:
         test_id_ = ui_resource_->id();
-        ui_resource_.reset();
+        ui_resource_ = nullptr;
         PostSetNeedsCommitToMainThread();
         break;
       case 5:
         // Release resource before ending the test.
-        ui_resource_.reset();
+        ui_resource_ = nullptr;
         EndTest();
         break;
       case 6:
         // Make sure no extra commits happened.
         NOTREACHED();
     }
   }
 
   virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     LayerTreeHostContextTest::CommitCompleteOnThread(impl);
@@ skipping 70 matching lines @@
         ui_resource_ = FakeScopedUIResource::Create(layer_tree_host());
         EXPECT_NE(0, ui_resource_->id());
         PostSetNeedsCommitToMainThread();
         break;
       case 2:
         // Make the tree not visible.
         PostSetVisibleToMainThread(false);
         break;
       case 3:
         // Release resource before ending the test.
-        ui_resource_.reset();
+        ui_resource_ = nullptr;
         EndTest();
         break;
       case 4:
         NOTREACHED();
     }
   }
 
   virtual void DidSetVisibleOnImplTree(LayerTreeHostImpl* impl,
                                        bool visible) OVERRIDE {
     TestWebGraphicsContext3D* context = TestContext();
@@ skipping 187 matching lines @@
   virtual void AfterTest() OVERRIDE {}
 
   bool deferred_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostContextTestLoseAfterSendingBeginMainFrame);
 
 }  // namespace
 }  // namespace cc