Remove implicit conversions from scoped_refptr to T* in cc/

cc/layers/layer_unittest.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/layers/layer.h"
 
 #include "cc/animation/keyframed_animation_curve.h"
 #include "cc/base/math_util.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/resources/layer_painter.h"
@@ skipping 149 matching lines @@
   scoped_refptr<Layer> child = Layer::Create();
 
   // Upon creation, layers should not have children or parent.
   ASSERT_EQ(0U, parent->children().size());
   EXPECT_FALSE(child->parent());
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, layer_tree_host_->SetRootLayer(parent));
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, parent->AddChild(child));
 
   ASSERT_EQ(1U, parent->children().size());
-  EXPECT_EQ(child.get(), parent->children()[0]);
+  EXPECT_EQ(child.get(), parent->children()[0].get());
   EXPECT_EQ(parent.get(), child->parent());
   EXPECT_EQ(parent.get(), child->RootLayer());
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(AtLeast(1), child->RemoveFromParent());
 }
 
 TEST_F(LayerTest, AddSameChildTwice) {
   EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times(AtLeast(1));
 
   scoped_refptr<Layer> parent = Layer::Create();
@@ skipping 204 matching lines @@
 
   ASSERT_EQ(2U, new_parent->children().size());
   EXPECT_EQ(new_parent.get(), child1->parent());
   EXPECT_EQ(new_parent.get(), child2->parent());
 
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, layer_tree_host_->SetRootLayer(NULL));
 }
 
 TEST_F(LayerTest, HasAncestor) {
   scoped_refptr<Layer> parent = Layer::Create();
-  EXPECT_FALSE(parent->HasAncestor(parent));
+  EXPECT_FALSE(parent->HasAncestor(parent.get()));
 
   scoped_refptr<Layer> child = Layer::Create();
   parent->AddChild(child);
 
-  EXPECT_FALSE(child->HasAncestor(child));
-  EXPECT_TRUE(child->HasAncestor(parent));
-  EXPECT_FALSE(parent->HasAncestor(child));
+  EXPECT_FALSE(child->HasAncestor(child.get()));
+  EXPECT_TRUE(child->HasAncestor(parent.get()));
+  EXPECT_FALSE(parent->HasAncestor(child.get()));
 
   scoped_refptr<Layer> child_child = Layer::Create();
   child->AddChild(child_child);
 
-  EXPECT_FALSE(child_child->HasAncestor(child_child));
-  EXPECT_TRUE(child_child->HasAncestor(parent));
-  EXPECT_TRUE(child_child->HasAncestor(child));
-  EXPECT_FALSE(parent->HasAncestor(child));
-  EXPECT_FALSE(parent->HasAncestor(child_child));
+  EXPECT_FALSE(child_child->HasAncestor(child_child.get()));
+  EXPECT_TRUE(child_child->HasAncestor(parent.get()));
+  EXPECT_TRUE(child_child->HasAncestor(child.get()));
+  EXPECT_FALSE(parent->HasAncestor(child.get()));
+  EXPECT_FALSE(parent->HasAncestor(child_child.get()));
 }
 
 TEST_F(LayerTest, GetRootLayerAfterTreeManipulations) {
   CreateSimpleTestTree();
 
   // For this test we don't care about SetNeedsFullTreeSync calls.
   EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times(AnyNumber());
 
   scoped_refptr<Layer> child4 = Layer::Create();
 
@@ skipping 353 matching lines @@
   scoped_refptr<Layer> replica_mask = Layer::Create();
   scoped_refptr<Layer> mask_replacement = Layer::Create();
   scoped_refptr<Layer> replica_replacement = Layer::Create();
   scoped_refptr<Layer> replica_mask_replacement = Layer::Create();
 
   parent->AddChild(child);
   child->SetMaskLayer(mask.get());
   child->SetReplicaLayer(replica.get());
   replica->SetMaskLayer(replica_mask.get());
 
-  EXPECT_EQ(parent, child->parent());
-  EXPECT_EQ(child, mask->parent());
-  EXPECT_EQ(child, replica->parent());
-  EXPECT_EQ(replica, replica_mask->parent());
+  EXPECT_EQ(parent.get(), child->parent());
+  EXPECT_EQ(child.get(), mask->parent());
+  EXPECT_EQ(child.get(), replica->parent());
+  EXPECT_EQ(replica.get(), replica_mask->parent());
 
   replica->SetMaskLayer(replica_mask_replacement.get());
   EXPECT_EQ(NULL, replica_mask->parent());
-  EXPECT_EQ(replica, replica_mask_replacement->parent());
+  EXPECT_EQ(replica.get(), replica_mask_replacement->parent());
 
   child->SetMaskLayer(mask_replacement.get());
   EXPECT_EQ(NULL, mask->parent());
-  EXPECT_EQ(child, mask_replacement->parent());
+  EXPECT_EQ(child.get(), mask_replacement->parent());
 
   child->SetReplicaLayer(replica_replacement.get());
   EXPECT_EQ(NULL, replica->parent());
-  EXPECT_EQ(child, replica_replacement->parent());
+  EXPECT_EQ(child.get(), replica_replacement->parent());
 
-  EXPECT_EQ(replica, replica->mask_layer()->parent());
+  EXPECT_EQ(replica.get(), replica->mask_layer()->parent());
 }
 
 TEST_F(LayerTest, CheckTranformIsInvertible) {
   scoped_refptr<Layer> layer = Layer::Create();
   scoped_ptr<LayerImpl> impl_layer =
       LayerImpl::Create(host_impl_.active_tree(), 1);
   EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times(1);
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AnyNumber());
   layer_tree_host_->SetRootLayer(layer);
 
@@ skipping 36 matching lines @@
 
   layer->SetTransform(singular_transform);
   layer->PushPropertiesTo(impl_layer.get());
 
   EXPECT_FALSE(layer->transform_is_invertible());
   EXPECT_FALSE(impl_layer->transform_is_invertible());
 
   gfx::Transform identity_transform;
 
   layer->SetTransform(identity_transform);
-  static_cast<LayerAnimationValueObserver*>(layer)
+  static_cast<LayerAnimationValueObserver*>(layer.get())
       ->OnTransformAnimated(singular_transform);
   layer->PushPropertiesTo(impl_layer.get());
   EXPECT_FALSE(layer->transform_is_invertible());
   EXPECT_FALSE(impl_layer->transform_is_invertible());
 
   Mock::VerifyAndClearExpectations(layer_tree_host_.get());
 }
 
 class LayerTreeHostFactory {
  public:
@@ skipping 321 matching lines @@
   root_layer->AddChild(becomes_not_draws_content);
   EXPECT_EQ(0, root_layer->NumDescendantsThatDrawContent());
 
   becomes_draws_content->SetIsDrawable(true);
   root_layer->AddChild(becomes_draws_content);
   EXPECT_EQ(1, root_layer->NumDescendantsThatDrawContent());
 }
 
 }  // namespace
 }  // namespace cc