Remove implicit conversions from scoped_refptr to T* in cc/trees/

cc/trees/layer_tree_host.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/trees/layer_tree_host.h"
 
 #include <algorithm>
 #include <stack>
 #include <string>
 
@@ skipping 53 matching lines @@
       using_shared_memory_resources(false) {}
 
 RendererCapabilities::~RendererCapabilities() {}
 
 scoped_ptr<LayerTreeHost> LayerTreeHost::CreateThreaded(
     LayerTreeHostClient* client,
     SharedBitmapManager* manager,
     const LayerTreeSettings& settings,
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner) {
-  DCHECK(main_task_runner);
-  DCHECK(impl_task_runner);
+  DCHECK(main_task_runner.get());
+  DCHECK(impl_task_runner.get());
   scoped_ptr<LayerTreeHost> layer_tree_host(
       new LayerTreeHost(client, manager, settings));
   layer_tree_host->InitializeThreaded(main_task_runner, impl_task_runner);
   return layer_tree_host.Pass();
 }
 
 scoped_ptr<LayerTreeHost> LayerTreeHost::CreateSingleThreaded(
     LayerTreeHostClient* client,
     LayerTreeHostSingleThreadClient* single_thread_client,
     SharedBitmapManager* manager,
@@ skipping 232 matching lines @@
     LayerImpl* hud_impl = LayerTreeHostCommon::FindLayerInSubtree(
         sync_tree->root_layer(), hud_layer_->id());
     sync_tree->set_hud_layer(static_cast<HeadsUpDisplayLayerImpl*>(hud_impl));
   } else {
     sync_tree->set_hud_layer(NULL);
   }
 
   sync_tree->set_background_color(background_color_);
   sync_tree->set_has_transparent_background(has_transparent_background_);
 
-  if (page_scale_layer_ && inner_viewport_scroll_layer_) {
-    sync_tree->SetViewportLayersFromIds(
-        page_scale_layer_->id(),
-        inner_viewport_scroll_layer_->id(),
-        outer_viewport_scroll_layer_ ? outer_viewport_scroll_layer_->id()
-                                     : Layer::INVALID_ID);
+  if (page_scale_layer_.get() && inner_viewport_scroll_layer_.get()) {
+    sync_tree->SetViewportLayersFromIds(page_scale_layer_->id(),
+                                        inner_viewport_scroll_layer_->id(),
+                                        outer_viewport_scroll_layer_.get()
+                                            ? outer_viewport_scroll_layer_->id()
+                                            : Layer::INVALID_ID);
   } else {
     sync_tree->ClearViewportLayers();
   }
 
   sync_tree->RegisterSelection(selection_start_, selection_end_);
 
   float page_scale_delta =
       sync_tree->page_scale_delta() / sync_tree->sent_page_scale_delta();
   sync_tree->SetPageScaleValues(page_scale_factor_,
                                 min_page_scale_factor_,
@@ skipping 445 matching lines @@
 bool LayerTreeHost::UpdateLayers(Layer* root_layer,
                                  ResourceUpdateQueue* queue) {
   TRACE_EVENT1("cc", "LayerTreeHost::UpdateLayers",
                "source_frame_number", source_frame_number());
 
   RenderSurfaceLayerList update_list;
   {
     UpdateHudLayer();
 
     Layer* root_scroll = FindFirstScrollableLayer(root_layer);
-    Layer* page_scale_layer = page_scale_layer_;
+    Layer* page_scale_layer = page_scale_layer_.get();
     if (!page_scale_layer && root_scroll)
       page_scale_layer = root_scroll->parent();
 
-    if (hud_layer_) {
+    if (hud_layer_.get()) {
       hud_layer_->PrepareForCalculateDrawProperties(
           device_viewport_size(), device_scale_factor_);
     }
 
     TRACE_EVENT0("cc", "LayerTreeHost::UpdateLayers::CalcDrawProps");
     bool can_render_to_separate_surface = true;
     // TODO(vmpstr): Passing 0 as the current render surface layer list id means
     // that we won't be able to detect if a layer is part of |update_list|.
     // Change this if this information is required.
     int render_surface_layer_list_id = 0;
@@ skipping 258 matching lines @@
   }
 
   if (!inner_viewport_scroll_delta.IsZero() ||
       !outer_viewport_scroll_delta.IsZero() || info->page_scale_delta != 1.f) {
     // SetScrollOffsetFromImplSide above could have destroyed the tree,
     // so re-get this layer before doing anything to it.
 
     // Preemptively apply the scroll offset and scale delta here before sending
     // it to the client.  If the client comes back and sets it to the same
     // value, then the layer can early out without needing a full commit.
-    DCHECK(inner_viewport_scroll_layer_);  // We should always have this.
+    DCHECK(inner_viewport_scroll_layer_.get());  // We should always have this.
 
     inner_viewport_scroll_layer_->SetScrollOffsetFromImplSide(
         inner_viewport_scroll_layer_->scroll_offset() +
         inner_viewport_scroll_delta);
-    if (outer_viewport_scroll_layer_) {
+    if (outer_viewport_scroll_layer_.get()) {
       outer_viewport_scroll_layer_->SetScrollOffsetFromImplSide(
           outer_viewport_scroll_layer_->scroll_offset() +
           outer_viewport_scroll_delta);
     }
     ApplyPageScaleDeltaFromImplSide(info->page_scale_delta);
 
     client_->ApplyScrollAndScale(
         inner_viewport_scroll_delta + outer_viewport_scroll_delta,
         info->page_scale_delta);
   }
@@ skipping 203 matching lines @@
   swap_promise_list_.push_back(swap_promise.Pass());
 }
 
 void LayerTreeHost::BreakSwapPromises(SwapPromise::DidNotSwapReason reason) {
   for (size_t i = 0; i < swap_promise_list_.size(); i++)
     swap_promise_list_[i]->DidNotSwap(reason);
   swap_promise_list_.clear();
 }
 
 }  // namespace cc