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

content/renderer/pepper/pepper_plugin_instance_impl.h

 // Copyright (c) 2012 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.
 
 #ifndef CONTENT_RENDERER_PEPPER_PEPPER_PLUGIN_INSTANCE_IMPL_H_
 #define CONTENT_RENDERER_PEPPER_PEPPER_PLUGIN_INSTANCE_IMPL_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <list>
+#include <memory>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/strings/string16.h"
 #include "build/build_config.h"
 #include "cc/layers/content_layer_client.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/texture_layer_client.h"
 #include "content/common/content_export.h"
 #include "content/public/renderer/pepper_plugin_instance.h"
 #include "content/public/renderer/plugin_instance_throttler.h"
 #include "content/public/renderer/render_frame.h"
@@ skipping 174 matching lines @@
   void InstanceCrashed();
 
   // PPB_Instance and PPB_Instance_Private implementation.
   bool full_frame() const { return full_frame_; }
   const ppapi::ViewData& view_data() const { return view_data_; }
 
   // PPP_Instance and PPP_Instance_Private.
   bool Initialize(const std::vector<std::string>& arg_names,
                   const std::vector<std::string>& arg_values,
                   bool full_frame,
-                  scoped_ptr<PluginInstanceThrottlerImpl> throttler);
+                  std::unique_ptr<PluginInstanceThrottlerImpl> throttler);
   bool HandleDocumentLoad(const blink::WebURLResponse& response);
   bool HandleInputEvent(const blink::WebInputEvent& event,
                         blink::WebCursorInfo* cursor_info);
   PP_Var GetInstanceObject(v8::Isolate* isolate);
   void ViewChanged(const gfx::Rect& window,
                    const gfx::Rect& clip,
                    const gfx::Rect& unobscured,
                    const std::vector<gfx::Rect>& cut_outs_rects);
 
   // Handlers for composition events.
@@ skipping 302 matching lines @@
   // Checks whether this is a valid instance of the given module. After calling
   // ResetAsProxied above, a NaCl plugin instance's module changes, so external
   // hosts won't recognize it as a valid instance of the original module. This
   // method fixes that be checking that either module_ or original_module_ match
   // the given module.
   bool IsValidInstanceOf(PluginModule* module);
 
   // cc::TextureLayerClient implementation.
   bool PrepareTextureMailbox(
       cc::TextureMailbox* mailbox,
-      scoped_ptr<cc::SingleReleaseCallback>* release_callback,
+      std::unique_ptr<cc::SingleReleaseCallback>* release_callback,
       bool use_shared_memory) override;
 
   // RenderFrameObserver
   void OnDestruct() override;
 
   // PluginInstanceThrottler::Observer
   void OnThrottleStateChange() override;
   void OnHiddenForPlaceholder(bool hidden) override;
 
  private:
@@ skipping 20 matching lines @@
                         int encoded_data_length) override;
     void didFinishLoading(blink::WebURLLoader* loader,
                           double finish_time,
                           int64_t total_encoded_data_length) override;
     void didFail(blink::WebURLLoader* loader,
                  const blink::WebURLError& error) override;
 
    private:
     std::list<std::string> data_;
     bool finished_loading_;
-    scoped_ptr<blink::WebURLError> error_;
+    std::unique_ptr<blink::WebURLError> error_;
   };
 
   // Implements PPB_Gamepad_API. This is just to avoid having an excessive
   // number of interfaces implemented by PepperPluginInstanceImpl.
   class GamepadImpl : public ppapi::thunk::PPB_Gamepad_API,
                       public ppapi::Resource {
    public:
     GamepadImpl();
     // Resource implementation.
     ppapi::thunk::PPB_Gamepad_API* AsPPB_Gamepad_API() override;
@@ skipping 105 matching lines @@
 
   void RecordFlashJavaScriptUse();
 
   // Converts the PP_Rect between DIP and Viewport.
   void ConvertRectToDIP(PP_Rect* rect) const;
   void ConvertDIPToViewport(gfx::Rect* rect) const;
 
   RenderFrameImpl* render_frame_;
   base::Closure instance_deleted_callback_;
   scoped_refptr<PluginModule> module_;
-  scoped_ptr<ppapi::PPP_Instance_Combined> instance_interface_;
+  std::unique_ptr<ppapi::PPP_Instance_Combined> instance_interface_;
   // If this is the NaCl plugin, we create a new module when we switch to the
   // IPC-based PPAPI proxy. Store the original module and instance interface
   // so we can shut down properly.
   scoped_refptr<PluginModule> original_module_;
-  scoped_ptr<ppapi::PPP_Instance_Combined> original_instance_interface_;
+  std::unique_ptr<ppapi::PPP_Instance_Combined> original_instance_interface_;
 
   PP_Instance pp_instance_;
 
   // NULL until we have been initialized.
   blink::WebPluginContainer* container_;
   scoped_refptr<cc::Layer> compositor_layer_;
   scoped_refptr<cc::TextureLayer> texture_layer_;
-  scoped_ptr<blink::WebLayer> web_layer_;
+  std::unique_ptr<blink::WebLayer> web_layer_;
   bool layer_bound_to_fullscreen_;
   bool layer_is_hardware_;
 
   // Plugin URL.
   const GURL plugin_url_;
 
   GURL document_url_;
 
   // Used to track Flash-specific metrics.
   const bool is_flash_plugin_;
 
   // Set to true the first time the plugin is clicked. Used to collect metrics.
   bool has_been_clicked_;
 
   // Used to track if JavaScript has ever been used for this plugin instance.
   bool javascript_used_;
 
   // Responsible for turning on throttling if Power Saver is on.
-  scoped_ptr<PluginInstanceThrottlerImpl> throttler_;
+  std::unique_ptr<PluginInstanceThrottlerImpl> throttler_;
 
   // Indicates whether this is a full frame instance, which means it represents
   // an entire document rather than an embed tag.
   bool full_frame_;
 
   // Stores the current state of the plugin view.
   ppapi::ViewData view_data_;
   // The last state sent to the plugin. It is only valid after
   // |sent_initial_did_change_view_| is set to true.
   ppapi::ViewData last_sent_view_data_;
@@ skipping 16 matching lines @@
   // all elements of the page, one one from the browser, which is whether the
   // tab/window has focus. We tell the plugin it has focus only when both of
   // these values are set to true.
   bool has_webkit_focus_;
   bool has_content_area_focus_;
 
   // The id of the current find operation, or -1 if none is in process.
   int find_identifier_;
 
   // Helper object that creates resources.
-  scoped_ptr<ppapi::thunk::ResourceCreationAPI> resource_creation_;
+  std::unique_ptr<ppapi::thunk::ResourceCreationAPI> resource_creation_;
 
   // The plugin-provided interfaces.
   // When adding PPP interfaces, make sure to reset them in ResetAsProxied.
   const PPP_Find_Private* plugin_find_interface_;
   const PPP_InputEvent* plugin_input_event_interface_;
   const PPP_MouseLock* plugin_mouse_lock_interface_;
   const PPP_Pdf* plugin_pdf_interface_;
   const PPP_Instance_Private* plugin_private_interface_;
   const PPP_TextInput_Dev* plugin_textinput_interface_;
 
@@ skipping 28 matching lines @@
   scoped_refptr<ppapi::Resource> gamepad_impl_;
   scoped_refptr<ppapi::Resource> uma_private_impl_;
 
   // The plugin print interface.
   const PPP_Printing_Dev* plugin_print_interface_;
 
   // The plugin 3D interface.
   const PPP_Graphics3D* plugin_graphics_3d_interface_;
 
   // Contains the cursor if it's set by the plugin.
-  scoped_ptr<blink::WebCursorInfo> cursor_;
+  std::unique_ptr<blink::WebCursorInfo> cursor_;
 
   // Set to true if this plugin thinks it will always be on top. This allows us
   // to use a more optimized painting path in some cases.
   bool always_on_top_;
   // Even if |always_on_top_| is true, the plugin is not fully visible if there
   // are some cut-out areas (occupied by iframes higher in the stacking order).
   // This information is used in the optimized painting path.
   std::vector<gfx::Rect> cut_outs_rects_;
 
   // Implementation of PPB_FlashFullscreen.
@@ skipping 64 matching lines @@
 
   // We store the arguments so we can re-send them if we are reset to talk to
   // NaCl via the IPC NaCl proxy.
   std::vector<std::string> argn_;
   std::vector<std::string> argv_;
 
   // Non-owning pointer to the document loader, if any.
   blink::WebURLLoaderClient* document_loader_;
   // State for deferring document loads. Used only by external instances.
   blink::WebURLResponse external_document_response_;
-  scoped_ptr<ExternalDocumentLoader> external_document_loader_;
+  std::unique_ptr<ExternalDocumentLoader> external_document_loader_;
   bool external_document_load_;
 
   // The ContentDecryptorDelegate forwards PPP_ContentDecryptor_Private
   // calls and handles PPB_ContentDecryptor_Private calls.
-  scoped_ptr<ContentDecryptorDelegate> content_decryptor_delegate_;
+  std::unique_ptr<ContentDecryptorDelegate> content_decryptor_delegate_;
 
   // The link currently under the cursor.
   base::string16 link_under_cursor_;
 
   // We store the isolate at construction so that we can be sure to use the
   // Isolate in which this Instance was created when interacting with v8.
   v8::Isolate* isolate_;
 
-  scoped_ptr<MouseLockDispatcher::LockTarget> lock_target_;
+  std::unique_ptr<MouseLockDispatcher::LockTarget> lock_target_;
 
   bool is_deleted_;
 
   // The text that is currently selected in the plugin.
   base::string16 selected_text_;
 
   bool initialized_;
 
   // We use a weak ptr factory for scheduling DidChangeView events so that we
   // can tell whether updates are pending and consolidate them. When there's
   // already a weak ptr pending (HasWeakPtrs is true), code should update the
   // view_data_ but not send updates. This also allows us to cancel scheduled
   // view change events.
   base::WeakPtrFactory<PepperPluginInstanceImpl> view_change_weak_ptr_factory_;
   base::WeakPtrFactory<PepperPluginInstanceImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(PepperPluginInstanceImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_PEPPER_PEPPER_PLUGIN_INSTANCE_IMPL_H_