Convert //chrome/browser/ui from scoped_ptr to std::unique_ptr

chrome/browser/ui/browser.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 CHROME_BROWSER_UI_BROWSER_H_
 #define CHROME_BROWSER_UI_BROWSER_H_
 
 #include <stdint.h>
 
 #include <map>
+#include <memory>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/scoped_observer.h"
 #include "base/strings/string16.h"
 #include "build/build_config.h"
 #include "chrome/browser/devtools/devtools_toggle_action.h"
 #include "chrome/browser/ui/bookmarks/bookmark_bar.h"
 #include "chrome/browser/ui/bookmarks/bookmark_tab_helper_delegate.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/chrome_bubble_manager.h"
 #include "chrome/browser/ui/chrome_web_modal_dialog_manager_delegate.h"
@@ skipping 210 matching lines @@
   bool is_trusted_source() const { return is_trusted_source_; }
   Profile* profile() const { return profile_; }
   gfx::Rect override_bounds() const { return override_bounds_; }
 
   // |window()| will return NULL if called before |CreateBrowserWindow()|
   // is done.
   BrowserWindow* window() const { return window_; }
   ToolbarModel* toolbar_model() { return toolbar_model_.get(); }
   const ToolbarModel* toolbar_model() const { return toolbar_model_.get(); }
 #if defined(UNIT_TEST)
-  void swap_toolbar_models(scoped_ptr<ToolbarModel>* toolbar_model) {
+  void swap_toolbar_models(std::unique_ptr<ToolbarModel>* toolbar_model) {
     toolbar_model->swap(toolbar_model_);
   }
 #endif
   TabStripModel* tab_strip_model() const { return tab_strip_model_.get(); }
   chrome::BrowserCommandController* command_controller() {
     return command_controller_.get();
   }
   SearchModel* search_model() { return search_model_.get(); }
   const SearchModel* search_model() const {
       return search_model_.get();
@@ skipping 213 matching lines @@
                              const blink::WebGestureEvent& event) override;
   bool CanDragEnter(content::WebContents* source,
                     const content::DropData& data,
                     blink::WebDragOperationsMask operations_allowed) override;
   content::SecurityStyle GetSecurityStyle(
       content::WebContents* web_contents,
       content::SecurityStyleExplanations* security_style_explanations) override;
   void ShowCertificateViewerInDevTools(
       content::WebContents* web_contents,
       int cert_id) override;
-  scoped_ptr<content::BluetoothChooser> RunBluetoothChooser(
+  std::unique_ptr<content::BluetoothChooser> RunBluetoothChooser(
       content::RenderFrameHost* frame,
       const content::BluetoothChooser::EventHandler& event_handler) override;
   void RequestAppBannerFromDevTools(
       content::WebContents* web_contents) override;
 
   bool RequestAppBanner(content::WebContents* web_contents);
 
   bool is_type_tabbed() const { return type_ == TYPE_TABBED; }
   bool is_type_popup() const { return type_ == TYPE_POPUP; }
 
@@ skipping 386 matching lines @@
 
   // This Browser's type.
   const Type type_;
 
   // This Browser's profile.
   Profile* const profile_;
 
   // This Browser's window.
   BrowserWindow* window_;
 
-  scoped_ptr<TabStripModelDelegate> tab_strip_model_delegate_;
-  scoped_ptr<TabStripModel> tab_strip_model_;
+  std::unique_ptr<TabStripModelDelegate> tab_strip_model_delegate_;
+  std::unique_ptr<TabStripModel> tab_strip_model_;
 
   // The application name that is also the name of the window to the shell.
   // This name should be set when:
   // 1) we launch an application via an application shortcut or extension API.
   // 2) we launch an undocked devtool window.
   std::string app_name_;
 
   // True if the source is trusted (i.e. we do not need to show the URL in a
   // a popup window). Also used to determine which app windows to save and
   // restore on Chrome OS.
   bool is_trusted_source_;
 
   // Unique identifier of this browser for session restore. This id is only
   // unique within the current session, and is not guaranteed to be unique
   // across sessions.
   const SessionID session_id_;
 
   // The model for the toolbar view.
-  scoped_ptr<ToolbarModel> toolbar_model_;
+  std::unique_ptr<ToolbarModel> toolbar_model_;
 
   // The model for the "active" search state.  There are per-tab search models
   // as well.  When a tab is active its model is kept in sync with this one.
   // When a new tab is activated its model state is propagated to this active
   // model.  This way, observers only have to attach to this single model for
   // updates, and don't have to worry about active tab changes directly.
-  scoped_ptr<SearchModel> search_model_;
+  std::unique_ptr<SearchModel> search_model_;
 
   // UI update coalescing and handling ////////////////////////////////////////
 
   typedef std::map<const content::WebContents*, int> UpdateMap;
 
   // Maps from WebContents to pending UI updates that need to be processed.
   // We don't update things like the URL or tab title right away to avoid
   // flickering and extra painting.
   // See ScheduleUIUpdate and ProcessPendingUIUpdates.
   UpdateMap scheduled_updates_;
@@ skipping 18 matching lines @@
   // These are supplied by callers that don't want to use the default values.
   // The default values are typically loaded from local state (last session),
   // obtained from the last window of the same type, or obtained from the
   // shell shortcut's startup info.
   gfx::Rect override_bounds_;
   ui::WindowShowState initial_show_state_;
 
   // Tracks when this browser is being created by session restore.
   bool is_session_restore_;
 
-  scoped_ptr<chrome::UnloadController> unload_controller_;
-  scoped_ptr<chrome::FastUnloadController> fast_unload_controller_;
+  std::unique_ptr<chrome::UnloadController> unload_controller_;
+  std::unique_ptr<chrome::FastUnloadController> fast_unload_controller_;
 
-  scoped_ptr<ChromeBubbleManager> bubble_manager_;
+  std::unique_ptr<ChromeBubbleManager> bubble_manager_;
 
   // The Find Bar. This may be NULL if there is no Find Bar, and if it is
   // non-NULL, it may or may not be visible.
-  scoped_ptr<FindBarController> find_bar_controller_;
+  std::unique_ptr<FindBarController> find_bar_controller_;
 
   // Dialog box used for opening and saving files.
   scoped_refptr<ui::SelectFileDialog> select_file_dialog_;
 
   // Keep track of the encoding auto detect pref.
   BooleanPrefMember encoding_auto_detect_;
 
   // Helper which implements the ContentSettingBubbleModel interface.
-  scoped_ptr<BrowserContentSettingBubbleModelDelegate>
+  std::unique_ptr<BrowserContentSettingBubbleModelDelegate>
       content_setting_bubble_model_delegate_;
 
   // Helper which implements the ToolbarModelDelegate interface.
-  scoped_ptr<BrowserToolbarModelDelegate> toolbar_model_delegate_;
+  std::unique_ptr<BrowserToolbarModelDelegate> toolbar_model_delegate_;
 
   // A delegate that handles the details of updating the "active"
   // |search_model_| state with the tab's state.
-  scoped_ptr<SearchDelegate> search_delegate_;
+  std::unique_ptr<SearchDelegate> search_delegate_;
 
   // Helper which implements the LiveTabContext interface.
-  scoped_ptr<BrowserLiveTabContext> live_tab_context_;
+  std::unique_ptr<BrowserLiveTabContext> live_tab_context_;
 
   // Helper which implements the SyncedWindowDelegate interface.
-  scoped_ptr<BrowserSyncedWindowDelegate> synced_window_delegate_;
+  std::unique_ptr<BrowserSyncedWindowDelegate> synced_window_delegate_;
 
-  scoped_ptr<BrowserInstantController> instant_controller_;
+  std::unique_ptr<BrowserInstantController> instant_controller_;
 
   // Helper which handles bookmark app specific browser configuration.
-  scoped_ptr<extensions::HostedAppBrowserController> hosted_app_controller_;
+  std::unique_ptr<extensions::HostedAppBrowserController>
+      hosted_app_controller_;
 
   BookmarkBar::State bookmark_bar_state_;
 
-  scoped_ptr<ExclusiveAccessManager> exclusive_access_manager_;
+  std::unique_ptr<ExclusiveAccessManager> exclusive_access_manager_;
 
-  scoped_ptr<extensions::WindowController> extension_window_controller_;
+  std::unique_ptr<extensions::WindowController> extension_window_controller_;
 
-  scoped_ptr<chrome::BrowserCommandController> command_controller_;
+  std::unique_ptr<chrome::BrowserCommandController> command_controller_;
 
   // True if the browser window has been shown at least once.
   bool window_has_shown_;
 
-  scoped_ptr<ValidationMessageBubble> validation_message_bubble_;
+  std::unique_ptr<ValidationMessageBubble> validation_message_bubble_;
 
   SigninViewController signin_view_controller_;
 
-  scoped_ptr<ScopedKeepAlive> keep_alive_;
+  std::unique_ptr<ScopedKeepAlive> keep_alive_;
 
   // The following factory is used for chrome update coalescing.
   base::WeakPtrFactory<Browser> chrome_updater_factory_;
 
   // The following factory is used to close the frame at a later time.
   base::WeakPtrFactory<Browser> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Browser);
 };
 
 #endif  // CHROME_BROWSER_UI_BROWSER_H_