Convert //content/browser from scoped_ptr to std::unique_ptr

content/browser/web_contents/aura/overscroll_navigation_overlay.cc

 // Copyright 2014 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/web_contents/aura/overscroll_navigation_overlay.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/i18n/rtl.h"
@@ skipping 35 matching lines @@
   return false;
 }
 
 }  // namespace
 
 // Responsible for fading out and deleting the layer of the overlay window.
 class OverlayDismissAnimator
     : public ui::LayerAnimationObserver {
  public:
   // Takes ownership of the layer.
-  explicit OverlayDismissAnimator(scoped_ptr<ui::Layer> layer)
+  explicit OverlayDismissAnimator(std::unique_ptr<ui::Layer> layer)
       : layer_(std::move(layer)) {
     CHECK(layer_.get());
   }
 
   // Starts the fadeout animation on the layer. When the animation finishes,
   // the object deletes itself along with the layer.
   void Animate() {
     DCHECK(layer_.get());
     ui::LayerAnimator* animator = layer_->GetAnimator();
     // This makes SetOpacity() animate with default duration (which could be
@@ skipping 11 matching lines @@
   void OnLayerAnimationAborted(ui::LayerAnimationSequence* sequence) override {
     delete this;
   }
 
   void OnLayerAnimationScheduled(
       ui::LayerAnimationSequence* sequence) override {}
 
  private:
   ~OverlayDismissAnimator() override {}
 
-  scoped_ptr<ui::Layer> layer_;
+  std::unique_ptr<ui::Layer> layer_;
 
   DISALLOW_COPY_AND_ASSIGN(OverlayDismissAnimator);
 };
 
 OverscrollNavigationOverlay::OverscrollNavigationOverlay(
     WebContentsImpl* web_contents,
     aura::Window* web_contents_window)
     : direction_(NONE),
       web_contents_(web_contents),
       loading_complete_(false),
@@ skipping 27 matching lines @@
   // for in-page navigations DidFirstVisuallyNonEmptyPaint() does not get
   // called, and we rely on loading_complete_ for those cases.
   // If an overscroll gesture is in progress, then do not destroy the window.
   if (!window_ || !(loading_complete_ || received_paint_update_) ||
       owa_->is_active()) {
     return;
   }
 
   // OverlayDismissAnimator deletes the dismiss layer and itself when the
   // animation completes.
-  scoped_ptr<ui::Layer> dismiss_layer = window_->AcquireLayer();
+  std::unique_ptr<ui::Layer> dismiss_layer = window_->AcquireLayer();
   window_.reset();
   (new OverlayDismissAnimator(std::move(dismiss_layer)))->Animate();
   Observe(nullptr);
   received_paint_update_ = false;
   loading_complete_ = false;
 }
 
-scoped_ptr<aura::Window> OverscrollNavigationOverlay::CreateOverlayWindow(
+std::unique_ptr<aura::Window> OverscrollNavigationOverlay::CreateOverlayWindow(
     const gfx::Rect& bounds) {
   UMA_HISTOGRAM_ENUMERATION(
       "Overscroll.Started2", direction_, NAVIGATION_COUNT);
   OverscrollWindowDelegate* overscroll_delegate = new OverscrollWindowDelegate(
       owa_.get(), GetImageForDirection(direction_));
-  scoped_ptr<aura::Window> window(new aura::Window(overscroll_delegate));
+  std::unique_ptr<aura::Window> window(new aura::Window(overscroll_delegate));
   window->set_owned_by_parent(false);
   window->SetTransparent(true);
   window->Init(ui::LAYER_TEXTURED);
   window->layer()->SetMasksToBounds(false);
   window->SetName("OverscrollOverlay");
   web_contents_window_->AddChild(window.get());
   aura::Window* event_window = GetMainWindow();
   if (direction_ == FORWARD)
     web_contents_window_->StackChildAbove(window.get(), event_window);
   else
@@ skipping 14 matching lines @@
       controller.GetEntryAtOffset(direction == FORWARD ? 1 : -1));
 
   if (entry && entry->screenshot().get()) {
     std::vector<gfx::ImagePNGRep> image_reps;
     image_reps.push_back(gfx::ImagePNGRep(entry->screenshot(), 1.0f));
     return gfx::Image(image_reps);
   }
   return gfx::Image();
 }
 
-scoped_ptr<aura::Window> OverscrollNavigationOverlay::CreateFrontWindow(
+std::unique_ptr<aura::Window> OverscrollNavigationOverlay::CreateFrontWindow(
     const gfx::Rect& bounds) {
   if (!web_contents_->GetController().CanGoForward())
     return nullptr;
   direction_ = FORWARD;
   return CreateOverlayWindow(bounds);
 }
 
-scoped_ptr<aura::Window> OverscrollNavigationOverlay::CreateBackWindow(
+std::unique_ptr<aura::Window> OverscrollNavigationOverlay::CreateBackWindow(
     const gfx::Rect& bounds) {
   if (!web_contents_->GetController().CanGoBack())
     return nullptr;
   direction_ = BACK;
   return CreateOverlayWindow(bounds);
 }
 
 aura::Window* OverscrollNavigationOverlay::GetMainWindow() const {
   if (window_)
     return window_.get();
   return web_contents_->IsBeingDestroyed()
              ? nullptr
              : web_contents_->GetContentNativeView();
 }
 
 void OverscrollNavigationOverlay::OnOverscrollCompleting() {
   aura::Window* main_window = GetMainWindow();
   if (!main_window)
     return;
   main_window->ReleaseCapture();
 }
 
 void OverscrollNavigationOverlay::OnOverscrollCompleted(
-    scoped_ptr<aura::Window> window) {
+    std::unique_ptr<aura::Window> window) {
   DCHECK(direction_ != NONE);
   aura::Window* main_window = GetMainWindow();
   if (!main_window) {
     UMA_HISTOGRAM_ENUMERATION(
         "Overscroll.Cancelled", direction_, NAVIGATION_COUNT);
     return;
   }
 
   // Make sure we can navigate first, as other factors can trigger a navigation
   // during an overscroll gesture and navigating without history produces a
@@ skipping 53 matching lines @@
 
 void OverscrollNavigationOverlay::DidStopLoading() {
   // Don't compare URLs in this case - it's possible they won't match if
   // a gesture-nav initiated navigation was interrupted by some other in-site
   // navigation (e.g., from a script, or from a bookmark).
   loading_complete_ = true;
   StopObservingIfDone();
 }
 
 }  // namespace content