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

content/renderer/render_frame_impl.h

 // Copyright 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.
 
 #ifndef CONTENT_RENDERER_RENDER_FRAME_IMPL_H_
 #define CONTENT_RENDERER_RENDER_FRAME_IMPL_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "base/files/file_path.h"
 #include "base/gtest_prod_util.h"
 #include "base/id_map.h"
 #include "base/macros.h"
 #include "base/memory/linked_ptr.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/process/process_handle.h"
 #include "build/build_config.h"
 #include "content/common/accessibility_mode_enums.h"
 #include "content/common/frame_message_enums.h"
 #include "content/common/mojo/service_registry_impl.h"
 #include "content/public/common/console_message_level.h"
 #include "content/public/common/javascript_message_type.h"
 #include "content/public/common/referrer.h"
@@ skipping 350 matching lines @@
   blink::WebElement GetFocusedElement() const override;
   WebPreferences& GetWebkitPreferences() override;
   int ShowContextMenu(ContextMenuClient* client,
                       const ContextMenuParams& params) override;
   void CancelContextMenu(int request_id) override;
   blink::WebNode GetContextMenuNode() const override;
   blink::WebPlugin* CreatePlugin(
       blink::WebFrame* frame,
       const WebPluginInfo& info,
       const blink::WebPluginParams& params,
-      scoped_ptr<PluginInstanceThrottler> throttler) override;
+      std::unique_ptr<PluginInstanceThrottler> throttler) override;
   void LoadURLExternally(const blink::WebURLRequest& request,
                          blink::WebNavigationPolicy policy) override;
   void ExecuteJavaScript(const base::string16& javascript) override;
   bool IsMainFrame() override;
   bool IsHidden() override;
   ServiceRegistry* GetServiceRegistry() override;
 #if defined(ENABLE_PLUGINS)
   void RegisterPeripheralPlugin(
       const url::Origin& content_origin,
       const base::Closure& unthrottle_callback) override;
@@ skipping 234 matching lines @@
   // Binds this render frame's service registry.
   void BindServiceRegistry(
       mojo::shell::mojom::InterfaceProviderRequest services,
       mojo::shell::mojom::InterfaceProviderPtr exposed_services);
 
   ManifestManager* manifest_manager();
 
   // TODO(creis): Remove when the only caller, the HistoryController, is no
   // more.
   void SetPendingNavigationParams(
-      scoped_ptr<NavigationParams> navigation_params);
+      std::unique_ptr<NavigationParams> navigation_params);
 
   media::MediaPermission* GetMediaPermission();
 
   // Sends the current frame's navigation state to the browser.
   void SendUpdateState();
 
   // Creates a MojoBindingsController if Mojo bindings have been enabled for
   // this frame. For WebUI, this allows the page to communicate with the browser
   // process; for layout tests, this allows the test to mock out services at
   // the Mojo IPC layer.
@@ skipping 167 matching lines @@
                bool is_history_navigation_in_new_child);
 
   // Performs a navigation in the frame. This provides a unified function for
   // the current code path and the browser-side navigation path (in
   // development). Currently used by OnNavigate, with all *NavigationParams
   // provided by the browser. |stream_params| should be null.
   // PlzNavigate: used by OnCommitNavigation, with |common_params| and
   // |request_params| received by the browser. |stream_params| should be non
   // null and created from the information provided by the browser.
   // |start_params| is not used.
-  void NavigateInternal(const CommonNavigationParams& common_params,
-                        const StartNavigationParams& start_params,
-                        const RequestNavigationParams& request_params,
-                        scoped_ptr<StreamOverrideParameters> stream_params);
+  void NavigateInternal(
+      const CommonNavigationParams& common_params,
+      const StartNavigationParams& start_params,
+      const RequestNavigationParams& request_params,
+      std::unique_ptr<StreamOverrideParameters> stream_params);
 
   // Update current main frame's encoding and send it to browser window.
   // Since we want to let users see the right encoding info from menu
   // before finishing loading, we call the UpdateEncoding in
   // a) function:DidCommitLoadForFrame. When this function is called,
   // that means we have got first data. In here we try to get encoding
   // of page if it has been specified in http header.
   // b) function:DidReceiveTitle. When this function is called,
   // that means we have got specified title. Because in most of webpages,
   // title tags will follow meta tags. In here we try to get encoding of
@@ skipping 33 matching lines @@
   // possible to create a MediaStreamClient (e.g., WebRTC is disabled), then
   // |web_user_media_client_| will remain NULL.
   void InitializeUserMediaClient();
 
   blink::WebMediaPlayer* CreateWebMediaPlayerForMediaStream(
       blink::WebMediaPlayerClient* client,
       const blink::WebString& sink_id,
       const blink::WebSecurityOrigin& security_origin);
 
   // Creates a factory object used for creating audio and video renderers.
-  scoped_ptr<MediaStreamRendererFactory> CreateRendererFactory();
+  std::unique_ptr<MediaStreamRendererFactory> CreateRendererFactory();
 
   // Does preparation for the navigation to |url|.
   void PrepareRenderViewForNavigation(
       const GURL& url,
       const RequestNavigationParams& request_params);
 
   // PlzNavigate
   // Sends a FrameHostMsg_BeginNavigation to the browser based on the contents
   // of the WebURLRequest.
   // |should_replace_current_entry| indicates that the current history entry
@@ skipping 134 matching lines @@
   int proxy_routing_id_;
 
   // Non-null when the RenderFrame is a local root for compositing, input,
   // layout, etc. A local frame is also a local root iff it does not have a
   // parent that is a local frame.
   scoped_refptr<RenderWidget> render_widget_;
 
   // Temporarily holds state pertaining to a navigation that has been initiated
   // until the NavigationState corresponding to the new navigation is created in
   // didCreateDataSource().
-  scoped_ptr<NavigationParams> pending_navigation_params_;
+  std::unique_ptr<NavigationParams> pending_navigation_params_;
 
   // Stores the current history item for this frame, so that updates to it can
   // be reported to the browser process via SendUpdateState.
   blink::WebHistoryItem current_history_item_;
 
 #if defined(ENABLE_PLUGINS)
   // Current text input composition text. Empty if no composition is in
   // progress.
   base::string16 pepper_composition_text_;
 
@@ skipping 44 matching lines @@
   // along with the RenderFrame automatically.  This is why we just store weak
   // references.
 
   // Dispatches permission requests for Web Notifications.
   NotificationPermissionDispatcher* notification_permission_dispatcher_;
 
   // Destroyed via the RenderFrameObserver::OnDestruct() mechanism.
   UserMediaClientImpl* web_user_media_client_;
 
   // EncryptedMediaClient attached to this frame; lazily initialized.
-  scoped_ptr<media::WebEncryptedMediaClientImpl> web_encrypted_media_client_;
+  std::unique_ptr<media::WebEncryptedMediaClientImpl>
+      web_encrypted_media_client_;
 
   // The media permission dispatcher attached to this frame.
-  scoped_ptr<MediaPermissionDispatcher> media_permission_dispatcher_;
+  std::unique_ptr<MediaPermissionDispatcher> media_permission_dispatcher_;
 
 #if defined(ENABLE_MOJO_MEDIA)
   // The media interface provider attached to this frame, lazily initialized.
-  scoped_ptr<MediaInterfaceProvider> media_interface_provider_;
+  std::unique_ptr<MediaInterfaceProvider> media_interface_provider_;
 #endif
 
   // MidiClient attached to this frame; lazily initialized.
   MidiDispatcher* midi_dispatcher_;
 
 #if defined(OS_ANDROID)
   // Manages all media players and sessions in this render frame for
   // communicating with the real media player and sessions in the
   // browser process. It's okay to use raw pointers since they're both
   // RenderFrameObservers.
   RendererMediaPlayerManager* media_player_manager_;
   RendererMediaSessionManager* media_session_manager_;
 #endif
 
   media::SurfaceManager* media_surface_manager_;
 
 #if defined(ENABLE_BROWSER_CDMS)
   // Manage all CDMs in this render frame for communicating with the real CDM in
   // the browser process. It's okay to use a raw pointer since it's a
   // RenderFrameObserver.
   RendererCdmManager* cdm_manager_;
 #endif
 
   // The CDM and decoder factory attached to this frame, lazily initialized.
-  scoped_ptr<media::CdmFactory> cdm_factory_;
-  scoped_ptr<media::DecoderFactory> decoder_factory_;
+  std::unique_ptr<media::CdmFactory> cdm_factory_;
+  std::unique_ptr<media::DecoderFactory> decoder_factory_;
 
   // Media resource cache, lazily initialized.
   linked_ptr<media::UrlIndex> url_index_;
 
 #if defined(VIDEO_HOLE)
   // Whether or not this RenderFrameImpl contains a media player. Used to
   // register as an observer for video-hole-specific events.
   bool contains_media_player_;
 #endif
 
@@ skipping 27 matching lines @@
   // process.
   ManifestManager* manifest_manager_;
 
   // The current accessibility mode.
   AccessibilityMode accessibility_mode_;
 
   // Only valid if |accessibility_mode_| is anything other than
   // AccessibilityModeOff.
   RendererAccessibility* renderer_accessibility_;
 
-  scoped_ptr<PermissionDispatcher> permission_client_;
+  std::unique_ptr<PermissionDispatcher> permission_client_;
 
-  scoped_ptr<blink::WebAppBannerClient> app_banner_client_;
+  std::unique_ptr<blink::WebAppBannerClient> app_banner_client_;
 
-  scoped_ptr<blink::WebBluetooth> bluetooth_;
+  std::unique_ptr<blink::WebBluetooth> bluetooth_;
 
-  scoped_ptr<blink::WebUSBClient> usb_client_;
+  std::unique_ptr<blink::WebUSBClient> usb_client_;
 
   // Manages play, pause notifications for WebMediaPlayer implementations; its
   // lifetime is tied to the RenderFrame via the RenderFrameObserver interface.
   media::RendererWebMediaPlayerDelegate* media_player_delegate_;
 
   // Whether or not this RenderFrame is using Lo-Fi mode.
   bool is_using_lofi_;
 
   // Whether or not this RenderFrame is currently pasting.
   bool is_pasting_;
 
   // Whether we must stop creating nested message loops for modal dialogs. This
   // is necessary because modal dialogs have a ScopedPageLoadDeferrer on the
   // stack that interferes with swapping out.
   bool suppress_further_dialogs_;
 
 #if defined(ENABLE_WEBVR)
   // The VR dispatcher attached to the frame, lazily initialized.
-  scoped_ptr<VRDispatcher> vr_dispatcher_;
+  std::unique_ptr<VRDispatcher> vr_dispatcher_;
 #endif
 
 #if defined(OS_MACOSX) || defined(OS_ANDROID)
   // The external popup for the currently showing select popup.
-  scoped_ptr<ExternalPopupMenu> external_popup_menu_;
+  std::unique_ptr<ExternalPopupMenu> external_popup_menu_;
 #endif
 
   FrameBlameContext* blame_context_;  // Not owned.
 
   base::WeakPtrFactory<RenderFrameImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderFrameImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_RENDER_FRAME_IMPL_H_