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

cc/trees/occlusion_tracker_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/trees/occlusion_tracker.h"
 
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/base/math_util.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
@@ skipping 103 matching lines @@
   typedef scoped_refptr<Layer> LayerPtrType;
   typedef scoped_refptr<ContentLayerType> ContentLayerPtrType;
   typedef LayerIterator<Layer> TestLayerIterator;
   typedef OcclusionTracker<Layer> OcclusionTrackerType;
 
   static LayerPtrType CreateLayer(HostType*  host) { return Layer::Create(); }
   static ContentLayerPtrType CreateContentLayer(HostType* host) {
     return make_scoped_refptr(new ContentLayerType());
   }
 
-  template <typename T>
-  static LayerPtrType PassLayerPtr(T* layer) {
+  static LayerPtrType PassLayerPtr(ContentLayerPtrType* layer) {
     LayerPtrType ref(*layer);
     *layer = NULL;
     return ref;
+  }
+
+  static LayerPtrType PassLayerPtr(LayerPtrType* layer) {
+    LayerPtrType ref(*layer);
+    *layer = NULL;
+    return ref;
   }
 
   static void DestroyLayer(LayerPtrType* layer) { *layer = NULL; }
 
   static void RecursiveUpdateNumChildren(LayerType* layerType) {}
 };
 
 struct OcclusionTrackerTestImplThreadTypes {
   typedef LayerImpl LayerType;
   typedef LayerTreeImpl HostType;
   typedef RenderSurfaceImpl RenderSurfaceType;
   typedef TestContentLayerImpl ContentLayerType;
   typedef scoped_ptr<LayerImpl> LayerPtrType;
   typedef scoped_ptr<ContentLayerType> ContentLayerPtrType;
   typedef LayerIterator<LayerImpl> TestLayerIterator;
   typedef OcclusionTracker<LayerImpl> OcclusionTrackerType;
 
   static LayerPtrType CreateLayer(HostType* host) {
     return LayerImpl::Create(host, next_layer_impl_id++);
   }
   static ContentLayerPtrType CreateContentLayer(HostType* host) {
     return make_scoped_ptr(new ContentLayerType(host, next_layer_impl_id++));
   }
   static int next_layer_impl_id;
 
-  template <typename T>
-  static LayerPtrType PassLayerPtr(T* layer) {
+  static LayerPtrType PassLayerPtr(LayerPtrType* layer) {
     return layer->Pass();
   }
 
+  static LayerPtrType PassLayerPtr(ContentLayerPtrType* layer) {
+    return layer->PassAs<LayerType>();
+  }
+
   static void DestroyLayer(LayerPtrType* layer) { layer->reset(); }
 
   static void RecursiveUpdateNumChildren(LayerType* layer) {
     FakeLayerTreeHostImpl::RecursiveUpdateNumChildren(layer);
   }
 };
 
 int OcclusionTrackerTestImplThreadTypes::next_layer_impl_id = 1;
 
 template <typename Types> class OcclusionTrackerTest : public testing::Test {
@@ skipping 102 matching lines @@
       const gfx::Size& bounds,
       bool opaque) {
     typename Types::ContentLayerType* layer =
         CreateDrawingLayer(parent, transform, position, bounds, opaque);
     layer->SetForceRenderSurface(true);
     return layer;
   }
 
   void DestroyLayers() {
     Types::DestroyLayer(&root_);
-    render_surface_layer_list_ = nullptr;
+    render_surface_layer_list_.reset();
     render_surface_layer_list_impl_.clear();
     replica_layers_.clear();
     mask_layers_.clear();
     ResetLayerIterator();
   }
 
   void CopyOutputCallback(scoped_ptr<CopyOutputResult> result) {}
 
   void AddCopyRequest(Layer* layer) {
     layer->RequestCopyOfOutput(
@@ skipping 3009 matching lines @@
     EXPECT_EQ(gfx::Rect(),
               occlusion.UnoccludedSurfaceContentRect(
                   surface, gfx::Rect(80, 70, 50, 50)));
   }
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestUnoccludedSurfaceQuery)
 
 }  // namespace
 }  // namespace cc