components/autofill: scoped_ptr -> unique_ptr

components/autofill/content/browser/risk/fingerprint.cc

 // 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.
 //
 // Generating a fingerprint consists of two major steps:
 //   (1) Gather all the necessary data.
 //   (2) Write it into a protocol buffer.
 //
 // Step (2) is as simple as it sounds -- it's really just a matter of copying
 // data.  Step (1) requires waiting on several asynchronous callbacks, which are
@@ skipping 166 matching lines @@
       const gfx::Rect& window_bounds,
       const gfx::Rect& content_bounds,
       const WebScreenInfo& screen_info,
       const std::string& version,
       const std::string& charset,
       const std::string& accept_languages,
       const base::Time& install_time,
       const std::string& app_locale,
       const std::string& user_agent,
       const base::TimeDelta& timeout,
-      const base::Callback<void(scoped_ptr<Fingerprint>)>& callback);
+      const base::Callback<void(std::unique_ptr<Fingerprint>)>& callback);
 
  private:
   ~FingerprintDataLoader() override {}
 
   // content::GpuDataManagerObserver:
   void OnGpuInfoUpdate() override;
 
   // Callbacks for asynchronously loaded data.
-  void OnGotFonts(scoped_ptr<base::ListValue> fonts);
+  void OnGotFonts(std::unique_ptr<base::ListValue> fonts);
   void OnGotPlugins(const std::vector<content::WebPluginInfo>& plugins);
   void OnGotGeoposition(const content::Geoposition& geoposition);
 
   // If all of the asynchronous data has been loaded, calls |callback_| with
   // the fingerprint data.
   void MaybeFillFingerprint();
 
   // Calls |callback_| with the fingerprint data.
   void FillFingerprint();
 
@@ skipping 12 matching lines @@
   const gfx::Rect content_bounds_;
   const WebScreenInfo screen_info_;
   const std::string version_;
   const std::string charset_;
   const std::string accept_languages_;
   const std::string app_locale_;
   const std::string user_agent_;
   const base::Time install_time_;
 
   // Data that will be loaded asynchronously.
-  scoped_ptr<base::ListValue> fonts_;
+  std::unique_ptr<base::ListValue> fonts_;
   std::vector<content::WebPluginInfo> plugins_;
   bool waiting_on_plugins_;
   content::Geoposition geoposition_;
 
   // Timer to enforce a maximum timeout before the |callback_| is called, even
   // if not all asynchronous data has been loaded.
   base::OneShotTimer timeout_timer_;
 
   // The callback that will be called once all the data is available.
-  base::Callback<void(scoped_ptr<Fingerprint>)> callback_;
+  base::Callback<void(std::unique_ptr<Fingerprint>)> callback_;
 
   // The callback used as an "observer" of the GeolocationProvider.
-  scoped_ptr<content::GeolocationProvider::Subscription>
+  std::unique_ptr<content::GeolocationProvider::Subscription>
       geolocation_subscription_;
 
   // For invalidating asynchronous callbacks that might arrive after |this|
   // instance is destroyed.
   base::WeakPtrFactory<FingerprintDataLoader> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(FingerprintDataLoader);
 };
 
 FingerprintDataLoader::FingerprintDataLoader(
     uint64_t obfuscated_gaia_id,
     const gfx::Rect& window_bounds,
     const gfx::Rect& content_bounds,
     const WebScreenInfo& screen_info,
     const std::string& version,
     const std::string& charset,
     const std::string& accept_languages,
     const base::Time& install_time,
     const std::string& app_locale,
     const std::string& user_agent,
     const base::TimeDelta& timeout,
-    const base::Callback<void(scoped_ptr<Fingerprint>)>& callback)
+    const base::Callback<void(std::unique_ptr<Fingerprint>)>& callback)
     : gpu_data_manager_(content::GpuDataManager::GetInstance()),
       gpu_observer_(this),
       obfuscated_gaia_id_(obfuscated_gaia_id),
       window_bounds_(window_bounds),
       content_bounds_(content_bounds),
       screen_info_(screen_info),
       version_(version),
       charset_(charset),
       accept_languages_(accept_languages),
       app_locale_(app_locale),
@@ skipping 38 matching lines @@
 }
 
 void FingerprintDataLoader::OnGpuInfoUpdate() {
   if (!gpu_data_manager_->IsEssentialGpuInfoAvailable())
     return;
 
   gpu_observer_.Remove(gpu_data_manager_);
   MaybeFillFingerprint();
 }
 
-void FingerprintDataLoader::OnGotFonts(scoped_ptr<base::ListValue> fonts) {
+void FingerprintDataLoader::OnGotFonts(std::unique_ptr<base::ListValue> fonts) {
   DCHECK(!fonts_);
   fonts_.reset(fonts.release());
   MaybeFillFingerprint();
 }
 
 void FingerprintDataLoader::OnGotPlugins(
     const std::vector<content::WebPluginInfo>& plugins) {
   DCHECK(waiting_on_plugins_);
   waiting_on_plugins_ = false;
   plugins_ = plugins;
@@ skipping 21 matching lines @@
        fonts_ &&
        !waiting_on_plugins_ &&
        (geoposition_.Validate() ||
         geoposition_.error_code != content::Geoposition::ERROR_CODE_NONE))) {
     FillFingerprint();
     delete this;
   }
 }
 
 void FingerprintDataLoader::FillFingerprint() {
-  scoped_ptr<Fingerprint> fingerprint(new Fingerprint);
+  std::unique_ptr<Fingerprint> fingerprint(new Fingerprint);
   Fingerprint::MachineCharacteristics* machine =
       fingerprint->mutable_machine_characteristics();
 
   machine->set_operating_system_build(GetOperatingSystemVersion());
   // We use the delta between the install time and the Unix epoch, in hours.
   machine->set_browser_install_time_hours(
       (install_time_ - base::Time::UnixEpoch()).InHours());
   machine->set_utc_offset_ms(GetTimezoneOffset().InMilliseconds());
   machine->set_browser_language(app_locale_);
   machine->set_charset(charset_);
@@ skipping 58 matching lines @@
     const gfx::Rect& window_bounds,
     const gfx::Rect& content_bounds,
     const blink::WebScreenInfo& screen_info,
     const std::string& version,
     const std::string& charset,
     const std::string& accept_languages,
     const base::Time& install_time,
     const std::string& app_locale,
     const std::string& user_agent,
     const base::TimeDelta& timeout,
-    const base::Callback<void(scoped_ptr<Fingerprint>)>& callback) {
+    const base::Callback<void(std::unique_ptr<Fingerprint>)>& callback) {
   // Begin loading all of the data that we need to load asynchronously.
   // This class is responsible for freeing its own memory.
   new FingerprintDataLoader(obfuscated_gaia_id, window_bounds, content_bounds,
                             screen_info, version, charset, accept_languages,
                             install_time, app_locale, user_agent, timeout,
                             callback);
 }
 
 }  // namespace internal
 
 void GetFingerprint(
     uint64_t obfuscated_gaia_id,
     const gfx::Rect& window_bounds,
     content::WebContents* web_contents,
     const std::string& version,
     const std::string& charset,
     const std::string& accept_languages,
     const base::Time& install_time,
     const std::string& app_locale,
     const std::string& user_agent,
-    const base::Callback<void(scoped_ptr<Fingerprint>)>& callback) {
+    const base::Callback<void(std::unique_ptr<Fingerprint>)>& callback) {
   gfx::Rect content_bounds = web_contents->GetContainerBounds();
 
   blink::WebScreenInfo screen_info;
   const content::RenderWidgetHostView* host_view =
       web_contents->GetRenderWidgetHostView();
   if (host_view)
     host_view->GetRenderWidgetHost()->GetWebScreenInfo(&screen_info);
 
   internal::GetFingerprintInternal(
       obfuscated_gaia_id, window_bounds, content_bounds, screen_info, version,
       charset, accept_languages, install_time, app_locale, user_agent,
       base::TimeDelta::FromSeconds(kTimeoutSeconds), callback);
 }
 
 }  // namespace risk
 }  // namespace autofill