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

cc/test/layer_tree_test.cc

 // Copyright 2011 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/test/layer_tree_test.h"
 
 #include "base/command_line.h"
 #include "cc/animation/animation.h"
 #include "cc/animation/animation_registrar.h"
 #include "cc/animation/layer_animation_controller.h"
@@ skipping 37 matching lines @@
 }
 
 // Adapts ThreadProxy for test. Injects test hooks for testing.
 class ThreadProxyForTest : public ThreadProxy {
  public:
   static scoped_ptr<Proxy> Create(
       TestHooks* test_hooks,
       LayerTreeHost* host,
       scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner) {
-    return make_scoped_ptr(
-               new ThreadProxyForTest(
-                   test_hooks, host, main_task_runner, impl_task_runner))
-        .PassAs<Proxy>();
+    return make_scoped_ptr(new ThreadProxyForTest(
+        test_hooks, host, main_task_runner, impl_task_runner));
   }
 
   virtual ~ThreadProxyForTest() {}
 
   void test() {
     test_hooks_->Layout();
   }
 
  private:
   TestHooks* test_hooks_;
@@ skipping 272 matching lines @@
     } else {
       layer_tree_host->InitializeForTesting(SingleThreadProxy::Create(
           layer_tree_host.get(), client, main_task_runner));
     }
     return layer_tree_host.Pass();
   }
 
   virtual scoped_ptr<LayerTreeHostImpl> CreateLayerTreeHostImpl(
       LayerTreeHostImplClient* host_impl_client) OVERRIDE {
     return LayerTreeHostImplForTesting::Create(
-               test_hooks_,
-               settings(),
-               host_impl_client,
-               proxy(),
-               shared_bitmap_manager_.get(),
-               rendering_stats_instrumentation()).PassAs<LayerTreeHostImpl>();
+        test_hooks_,
+        settings(),
+        host_impl_client,
+        proxy(),
+        shared_bitmap_manager_.get(),
+        rendering_stats_instrumentation());
   }
 
   virtual void SetNeedsCommit() OVERRIDE {
     if (!test_started_)
       return;
     LayerTreeHost::SetNeedsCommit();
   }
 
   void set_test_started(bool started) { test_started_ = started; }
 
@@ skipping 277 matching lines @@
         timeout_.callback(),
         base::TimeDelta::FromSeconds(timeout_seconds_));
   }
 
   base::MessageLoop::current()->Run();
   DestroyLayerTreeHost();
 
   timeout_.Cancel();
 
   ASSERT_FALSE(layer_tree_host_.get());
-  client_.reset();
+  client_ = nullptr;
   if (timed_out_) {
     FAIL() << "Test timed out";
     return;
   }
   AfterTest();
 }
 
 void LayerTreeTest::RunTestWithImplSidePainting() {
   RunTest(true, false, true);
 }
 
 void LayerTreeTest::RequestNewOutputSurface(bool fallback) {
   layer_tree_host_->SetOutputSurface(CreateOutputSurface(fallback));
 }
 
 scoped_ptr<OutputSurface> LayerTreeTest::CreateOutputSurface(bool fallback) {
   scoped_ptr<FakeOutputSurface> output_surface =
       CreateFakeOutputSurface(fallback);
   if (output_surface) {
     DCHECK_EQ(delegating_renderer_,
               output_surface->capabilities().delegated_rendering);
   }
   output_surface_ = output_surface.get();
-  return output_surface.PassAs<OutputSurface>();
+  return output_surface.Pass();
 }
 
 scoped_ptr<FakeOutputSurface> LayerTreeTest::CreateFakeOutputSurface(
     bool fallback) {
   if (delegating_renderer_)
     return FakeOutputSurface::CreateDelegating3d();
   else
     return FakeOutputSurface::Create3d();
 }
 
 TestWebGraphicsContext3D* LayerTreeTest::TestContext() {
   return static_cast<TestContextProvider*>(output_surface_->context_provider())
       ->TestContext3d();
 }
 
 int LayerTreeTest::LastCommittedSourceFrameNumber(LayerTreeHostImpl* impl)
     const {
   if (impl->pending_tree())
     return impl->pending_tree()->source_frame_number();
   if (impl->active_tree())
     return impl->active_tree()->source_frame_number();
   // Source frames start at 0, so this is invalid.
   return -1;
 }
 
 void LayerTreeTest::DestroyLayerTreeHost() {
   if (layer_tree_host_ && layer_tree_host_->root_layer())
     layer_tree_host_->root_layer()->SetLayerTreeHost(NULL);
-  layer_tree_host_.reset();
+  layer_tree_host_ = nullptr;
 }
 
 }  // namespace cc