Update Android to use scoped_refptr<T>::get() rather than implicit "operator T*"

content/browser/android/edge_effect.cc

 // Copyright (c) 2013 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 "content/browser/android/edge_effect.h"
 
 #include "cc/layers/layer.h"
 #include "ui/gfx/screen.h"
 
 namespace content {
@@ skipping 121 matching lines @@
   , edge_scale_y_start_(0)
   , edge_scale_y_finish_(0)
   , glow_alpha_start_(0)
   , glow_alpha_finish_(0)
   , glow_scale_y_start_(0)
   , glow_scale_y_finish_(0)
   , state_(STATE_IDLE)
   , pull_distance_(0)
   , dpi_scale_(1) {
   // Prevent the provided layers from drawing until the effect is activated.
-  DisableLayer(edge_);
-  DisableLayer(glow_);
+  DisableLayer(edge_.get());
+  DisableLayer(glow_.get());
 
   dpi_scale_ =
       gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().device_scale_factor();
 }
 
 EdgeEffect::~EdgeEffect() { }
 
 bool EdgeEffect::IsFinished() const {
   return state_ == STATE_IDLE;
 }
 
 void EdgeEffect::Finish() {
-  DisableLayer(edge_);
-  DisableLayer(glow_);
+  DisableLayer(edge_.get());
+  DisableLayer(glow_.get());
   pull_distance_ = 0;
   state_ = STATE_IDLE;
 }
 
 void EdgeEffect::Pull(base::TimeTicks current_time, float delta_distance) {
   if (state_ == STATE_PULL_DECAY && current_time - start_time_ < duration_) {
     return;
   }
   if (state_ != STATE_PULL) {
     glow_scale_y_ = kPullGlowBegin;
@@ skipping 163 matching lines @@
   return !IsFinished();
 }
 
 void EdgeEffect::ApplyToLayers(gfx::SizeF size, Edge edge) {
   if (IsFinished())
     return;
 
   // An empty effect size, while meaningless, is also relatively harmless, and
   // will simply prevent any drawing of the layers.
   if (size.IsEmpty()) {
-    DisableLayer(edge_);
-    DisableLayer(glow_);
+    DisableLayer(edge_.get());
+    DisableLayer(glow_.get());
     return;
   }
 
   float dummy_scale_x, dummy_scale_y;
 
   // Glow
   gfx::Size glow_image_bounds;
   glow_->CalculateContentsScale(1.f, 1.f, 1.f, false,
                                 &dummy_scale_x, &dummy_scale_y,
                                 &glow_image_bounds);
   const int glow_height = glow_image_bounds.height();
   const int glow_bottom = static_cast<int>(std::min(
       glow_height * glow_scale_y_ * kGlowImageAspectRatioInverse * 0.6f,
       glow_height * kMaxGlowHeight) * dpi_scale_ + 0.5f);
-  UpdateLayer(glow_, edge, size, glow_bottom, glow_alpha_);
+  UpdateLayer(glow_.get(), edge, size, glow_bottom, glow_alpha_);
 
   // Edge
   gfx::Size edge_image_bounds;
   edge_->CalculateContentsScale(1.f, 1.f, 1.f, false,
                                 &dummy_scale_x, &dummy_scale_y,
                                 &edge_image_bounds);
   const int edge_height = edge_image_bounds.height();
   const int edge_bottom = static_cast<int>(
       edge_height * edge_scale_y_ * dpi_scale_);
-  UpdateLayer(edge_, edge, size, edge_bottom, edge_alpha_);
+  UpdateLayer(edge_.get(), edge, size, edge_bottom, edge_alpha_);
 }
 
 } // namespace content