Convert //components/[a-e]* from scoped_ptr to std::unique_ptr

components/error_page/renderer/net_error_helper_core_unittest.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.
 
 #include "components/error_page/renderer/net_error_helper_core.h"
 
 #include <stddef.h>
 
 #include <map>
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/histogram_tester.h"
@@ skipping 163 matching lines @@
   void SetUpCore(bool auto_reload_enabled,
                  bool auto_reload_visible_only,
                  bool visible) {
     // The old value of timer_, if any, will be freed by the old core_ being
     // destructed, since core_ takes ownership of the timer.
     timer_ = new base::MockTimer(false, false);
     core_.reset(new NetErrorHelperCore(this,
                                        auto_reload_enabled,
                                        auto_reload_visible_only,
                                        visible));
-    core_->set_timer_for_testing(scoped_ptr<base::Timer>(timer_));
+    core_->set_timer_for_testing(std::unique_ptr<base::Timer>(timer_));
   }
 
   NetErrorHelperCore* core() { return core_.get(); }
 
   const GURL& url_being_fetched() const { return url_being_fetched_; }
   bool is_url_being_fetched() const { return !url_being_fetched_.is_empty(); }
 
   int reload_count() const {
     return reload_count_;
   }
@@ skipping 145 matching lines @@
     core()->OnSetNavigationCorrectionInfo(navigation_correction_url,
                                           kLanguage, kCountry, kApiKey,
                                           GURL(kSearchUrl));
   }
 
   // NetErrorHelperCore::Delegate implementation:
   void GenerateLocalizedErrorPage(const WebURLError& error,
                                   bool is_failed_post,
                                   bool can_show_network_diagnostics_dialog,
                                   bool has_offline_pages,
-                                  scoped_ptr<ErrorPageParams> params,
+                                  std::unique_ptr<ErrorPageParams> params,
                                   bool* reload_button_shown,
                                   bool* show_saved_copy_button_shown,
                                   bool* show_cached_copy_button_shown,
                                   bool* show_offline_pages_button_shown,
                                   std::string* html) const override {
     last_can_show_network_diagnostics_dialog_ =
         can_show_network_diagnostics_dialog;
     last_has_offline_pages_ = has_offline_pages;
     last_error_page_params_.reset(params.release());
     *reload_button_shown = false;
@@ skipping 30 matching lines @@
     EXPECT_TRUE(url_being_fetched_.is_empty());
     EXPECT_TRUE(request_body_.empty());
     EXPECT_EQ(GURL(kNavigationCorrectionUrl), navigation_correction_url);
 
     url_being_fetched_ = navigation_correction_url;
     request_body_ = navigation_correction_request_body;
 
     // Check the body of the request.
 
     base::JSONReader reader;
-    scoped_ptr<base::Value> parsed_body(reader.Read(
-        navigation_correction_request_body));
+    std::unique_ptr<base::Value> parsed_body(
+        reader.Read(navigation_correction_request_body));
     ASSERT_TRUE(parsed_body);
     base::DictionaryValue* dict = NULL;
     ASSERT_TRUE(parsed_body->GetAsDictionary(&dict));
 
     EXPECT_TRUE(StringValueEquals(*dict, "params.urlQuery", kFailedUrl));
     EXPECT_TRUE(StringValueEquals(*dict, "params.language", kLanguage));
     EXPECT_TRUE(StringValueEquals(*dict, "params.originCountry", kCountry));
     EXPECT_TRUE(StringValueEquals(*dict, "params.key", kApiKey));
   }
 
@@ skipping 22 matching lines @@
 
   void SendTrackingRequest(const GURL& tracking_url,
                            const std::string& tracking_request_body) override {
     last_tracking_url_ = tracking_url;
     last_tracking_request_body_ = tracking_request_body;
     tracking_request_count_++;
 
     // Check the body of the request.
 
     base::JSONReader reader;
-    scoped_ptr<base::Value> parsed_body(reader.Read(tracking_request_body));
+    std::unique_ptr<base::Value> parsed_body(
+        reader.Read(tracking_request_body));
     ASSERT_TRUE(parsed_body);
     base::DictionaryValue* dict = NULL;
     ASSERT_TRUE(parsed_body->GetAsDictionary(&dict));
 
     EXPECT_TRUE(StringValueEquals(*dict, "params.originalUrlQuery",
                                   kFailedUrl));
     EXPECT_TRUE(StringValueEquals(*dict, "params.language", kLanguage));
     EXPECT_TRUE(StringValueEquals(*dict, "params.originCountry", kCountry));
     EXPECT_TRUE(StringValueEquals(*dict, "params.key", kApiKey));
   }
 
   base::MockTimer* timer_;
 
-  scoped_ptr<NetErrorHelperCore> core_;
+  std::unique_ptr<NetErrorHelperCore> core_;
 
   GURL url_being_fetched_;
   std::string request_body_;
 
   // Contains the information passed to the last call to UpdateErrorPage, as a
   // string.
   std::string last_update_string_;
   // Number of times |last_update_string_| has been changed.
   int update_count_;
 
   // Contains the HTML set by the last call to LoadErrorPageInMainFrame.
   std::string last_error_html_;
   // Number of times |last_error_html_| has been changed.
   int error_html_update_count_;
 
   // Values passed in to the last call of GenerateLocalizedErrorPage or
   // UpdateErrorPage.  Mutable because GenerateLocalizedErrorPage is const.
   mutable bool last_can_show_network_diagnostics_dialog_;
   mutable bool last_has_offline_pages_;
-  mutable scoped_ptr<ErrorPageParams> last_error_page_params_;
+  mutable std::unique_ptr<ErrorPageParams> last_error_page_params_;
 
   int reload_count_;
   int reload_bypassing_cache_count_;
   int show_saved_copy_count_;
   GURL show_saved_copy_url_;
   int diagnose_error_count_;
   GURL diagnose_error_url_;
   int show_offline_pages_count_;
 
   int enable_page_helper_functions_count_;
@@ skipping 2082 matching lines @@
   DoErrorLoad(net::ERR_INTERNET_DISCONNECTED);
   EXPECT_TRUE(last_has_offline_pages());
   EXPECT_EQ(0, show_offline_pages_count());
   core()->ExecuteButtonPress(NetErrorHelperCore::SHOW_OFFLINE_PAGES_BUTTON);
   EXPECT_EQ(1, show_offline_pages_count());
 }
 #endif  // defined(OS_ANDROID)
 
 }  // namespace
 }  // namespace error_page