Replace scoped_ptr with std::unique_ptr in //ui

ui/ozone/demo/ozone_demo.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 <utility>
 
 #include "base/at_exit.h"
 #include "base/command_line.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "ui/display/types/display_snapshot.h"
 #include "ui/display/types/native_display_delegate.h"
 #include "ui/display/types/native_display_observer.h"
 #include "ui/events/event.h"
 #include "ui/events/keycodes/dom/dom_code.h"
 #include "ui/events/ozone/layout/keyboard_layout_engine.h"
@@ skipping 34 matching lines @@
  public:
   enum RendererType {
     GL,
     SOFTWARE,
   };
 
   RendererFactory();
   ~RendererFactory();
 
   bool Initialize();
-  scoped_ptr<ui::Renderer> CreateRenderer(gfx::AcceleratedWidget widget,
-                                          const gfx::Size& size);
+  std::unique_ptr<ui::Renderer> CreateRenderer(gfx::AcceleratedWidget widget,
+                                               const gfx::Size& size);
 
  private:
   RendererType type_ = SOFTWARE;
 
   // Helper for applications that do GL on main thread.
   ui::OzoneGpuTestHelper gpu_helper_;
 
   DISALLOW_COPY_AND_ASSIGN(RendererFactory);
 };
 
 class WindowManager : public ui::NativeDisplayObserver {
  public:
   WindowManager(const base::Closure& quit_closure);
   ~WindowManager() override;
 
   void Quit();
 
   void AddWindow(DemoWindow* window);
   void RemoveWindow(DemoWindow* window);
 
  private:
   void OnDisplaysAquired(const std::vector<ui::DisplaySnapshot*>& displays);
   void OnDisplayConfigured(const gfx::Rect& bounds, bool success);
 
   // ui::NativeDisplayDelegate:
   void OnConfigurationChanged() override;
 
-  scoped_ptr<ui::NativeDisplayDelegate> delegate_;
+  std::unique_ptr<ui::NativeDisplayDelegate> delegate_;
   base::Closure quit_closure_;
   RendererFactory renderer_factory_;
-  std::vector<scoped_ptr<DemoWindow>> windows_;
+  std::vector<std::unique_ptr<DemoWindow>> windows_;
 
   // Flags used to keep track of the current state of display configuration.
   //
   // True if configuring the displays. In this case a new display configuration
   // isn't started.
   bool is_configuring_ = false;
 
   // If |is_configuring_| is true and another display configuration event
   // happens, the event is deferred. This is set to true and a display
   // configuration will be scheduled after the current one finishes.
@@ skipping 60 matching lines @@
   // initialize the GPU resources via a posted task.
   void StartOnGpu() {
     renderer_ =
         renderer_factory_->CreateRenderer(GetAcceleratedWidget(), GetSize());
     renderer_->Initialize();
   }
 
   WindowManager* window_manager_;      // Not owned.
   RendererFactory* renderer_factory_;  // Not owned.
 
-  scoped_ptr<ui::Renderer> renderer_;
+  std::unique_ptr<ui::Renderer> renderer_;
 
   // Window-related state.
-  scoped_ptr<ui::PlatformWindow> platform_window_;
+  std::unique_ptr<ui::PlatformWindow> platform_window_;
   gfx::AcceleratedWidget widget_ = gfx::kNullAcceleratedWidget;
 
   base::WeakPtrFactory<DemoWindow> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DemoWindow);
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // RendererFactory implementation:
 
@@ skipping 10 matching lines @@
       gpu_helper_.Initialize(base::ThreadTaskRunnerHandle::Get(),
                              base::ThreadTaskRunnerHandle::Get())) {
     type_ = GL;
   } else {
     type_ = SOFTWARE;
   }
 
   return true;
 }
 
-scoped_ptr<ui::Renderer> RendererFactory::CreateRenderer(
+std::unique_ptr<ui::Renderer> RendererFactory::CreateRenderer(
     gfx::AcceleratedWidget widget,
     const gfx::Size& size) {
   switch (type_) {
     case GL: {
       scoped_refptr<gfx::GLSurface> surface = CreateGLSurface(widget);
       if (!surface)
         LOG(FATAL) << "Failed to create GL surface";
       if (surface->IsSurfaceless())
-        return make_scoped_ptr(
+        return base::WrapUnique(
             new ui::SurfacelessGlRenderer(widget, surface, size));
       else
-        return make_scoped_ptr(new ui::GlRenderer(widget, surface, size));
+        return base::WrapUnique(new ui::GlRenderer(widget, surface, size));
     }
     case SOFTWARE:
-      return make_scoped_ptr(new ui::SoftwareRenderer(widget, size));
+      return base::WrapUnique(new ui::SoftwareRenderer(widget, size));
   }
 
   return nullptr;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // WindowManager implementation:
 
 WindowManager::WindowManager(const base::Closure& quit_closure)
     : delegate_(
@@ skipping 66 matching lines @@
   if (should_configure_) {
     should_configure_ = false;
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&WindowManager::OnConfigurationChanged,
                               base::Unretained(this)));
   }
 }
 
 void WindowManager::OnDisplayConfigured(const gfx::Rect& bounds, bool success) {
   if (success) {
-    scoped_ptr<DemoWindow> window(
+    std::unique_ptr<DemoWindow> window(
         new DemoWindow(this, &renderer_factory_, bounds));
     window->Start();
     windows_.push_back(std::move(window));
   } else {
     LOG(ERROR) << "Failed to configure display at " << bounds.ToString();
   }
 }
 
 int main(int argc, char** argv) {
   base::CommandLine::Init(argc, argv);
@@ skipping 12 matching lines @@
       ->SetCurrentLayoutByName("us");
 
   base::RunLoop run_loop;
 
   WindowManager window_manager(run_loop.QuitClosure());
 
   run_loop.Run();
 
   return 0;
 }