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

content/browser/devtools/protocol/devtools_protocol_browsertest.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 <stddef.h>
 #include <utility>
 
 #include "base/base64.h"
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
@@ skipping 29 matching lines @@
                              public DevToolsAgentHostClient {
  public:
   DevToolsProtocolTest()
       : last_sent_id_(0),
         waiting_for_command_result_id_(0),
         in_dispatch_(false) {
   }
 
  protected:
   void SendCommand(const std::string& method,
-                   scoped_ptr<base::DictionaryValue> params) {
+                   std::unique_ptr<base::DictionaryValue> params) {
     SendCommand(method, std::move(params), true);
   }
 
   void SendCommand(const std::string& method,
-                   scoped_ptr<base::DictionaryValue> params,
+                   std::unique_ptr<base::DictionaryValue> params,
                    bool wait) {
     in_dispatch_ = true;
     base::DictionaryValue command;
     command.SetInteger(kIdParam, ++last_sent_id_);
     command.SetString(kMethodParam, method);
     if (params)
       command.Set(kParamsParam, params.release());
 
     std::string json_command;
     base::JSONWriter::Write(command, &json_command);
@@ skipping 42 matching lines @@
       agent_host_->DetachClient();
       agent_host_ = nullptr;
     }
   }
 
   void WaitForNotification(const std::string& notification) {
     waiting_for_notification_ = notification;
     RunMessageLoop();
   }
 
-  scoped_ptr<base::DictionaryValue> result_;
+  std::unique_ptr<base::DictionaryValue> result_;
   scoped_refptr<DevToolsAgentHost> agent_host_;
   int last_sent_id_;
   std::vector<int> result_ids_;
   std::vector<std::string> notifications_;
 
  private:
   void DispatchProtocolMessage(DevToolsAgentHost* agent_host,
                                const std::string& message) override {
-    scoped_ptr<base::DictionaryValue> root(static_cast<base::DictionaryValue*>(
-        base::JSONReader::Read(message).release()));
+    std::unique_ptr<base::DictionaryValue> root(
+        static_cast<base::DictionaryValue*>(
+            base::JSONReader::Read(message).release()));
     int id;
     if (root->GetInteger("id", &id)) {
       result_ids_.push_back(id);
       base::DictionaryValue* result;
       ASSERT_TRUE(root->GetDictionary("result", &result));
       result_.reset(result->DeepCopy());
       in_dispatch_ = false;
       if (id && id == waiting_for_command_result_id_) {
         waiting_for_command_result_id_ = 0;
         base::MessageLoop::current()->QuitNow();
@@ skipping 17 matching lines @@
   int waiting_for_command_result_id_;
   bool in_dispatch_;
 };
 
 class SyntheticKeyEventTest : public DevToolsProtocolTest {
  protected:
   void SendKeyEvent(const std::string& type,
                     int modifier,
                     int windowsKeyCode,
                     int nativeKeyCode) {
-    scoped_ptr<base::DictionaryValue> params(new base::DictionaryValue());
+    std::unique_ptr<base::DictionaryValue> params(new base::DictionaryValue());
     params->SetString("type", type);
     params->SetInteger("modifiers", modifier);
     params->SetInteger("windowsVirtualKeyCode", windowsKeyCode);
     params->SetInteger("nativeVirtualKeyCode", nativeKeyCode);
     SendCommand("Input.dispatchKeyEvent", std::move(params));
   }
 };
 
 IN_PROC_BROWSER_TEST_F(SyntheticKeyEventTest, KeyEventSynthesizeKeyIdentifier) {
   NavigateToURLBlockUntilNavigationsComplete(shell(), GURL("about:blank"), 1);
@@ skipping 79 matching lines @@
   int old_width;
   ASSERT_TRUE(content::ExecuteScriptAndExtractInt(
       shell()->web_contents(),
       "domAutomationController.send(window.innerWidth)", &old_width));
 
   int old_height;
   ASSERT_TRUE(content::ExecuteScriptAndExtractInt(
       shell()->web_contents(),
       "domAutomationController.send(window.innerHeight)", &old_height));
 
-  scoped_ptr<base::DictionaryValue> params(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> params(new base::DictionaryValue());
   params->SetInteger("x", old_width / 2);
   params->SetInteger("y", old_height / 2);
   params->SetDouble("scaleFactor", 2.0);
   SendCommand("Input.synthesizePinchGesture", std::move(params));
 
   int new_width;
   ASSERT_TRUE(content::ExecuteScriptAndExtractInt(
       shell()->web_contents(),
       "domAutomationController.send(window.innerWidth)", &new_width));
   ASSERT_DOUBLE_EQ(2.0, static_cast<double>(old_width) / new_width);
 
   int new_height;
   ASSERT_TRUE(content::ExecuteScriptAndExtractInt(
       shell()->web_contents(),
       "domAutomationController.send(window.innerHeight)", &new_height));
   ASSERT_DOUBLE_EQ(2.0, static_cast<double>(old_height) / new_height);
 }
 
 IN_PROC_BROWSER_TEST_F(DevToolsProtocolTest, DISABLED_SynthesizeScrollGesture) {
   GURL test_url = GetTestUrl("devtools", "synthetic_gesture_tests.html");
   NavigateToURLBlockUntilNavigationsComplete(shell(), test_url, 1);
   Attach();
 
   int scroll_top;
   ASSERT_TRUE(content::ExecuteScriptAndExtractInt(
       shell()->web_contents(),
       "domAutomationController.send(document.body.scrollTop)", &scroll_top));
   ASSERT_EQ(0, scroll_top);
 
-  scoped_ptr<base::DictionaryValue> params(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> params(new base::DictionaryValue());
   params->SetInteger("x", 0);
   params->SetInteger("y", 0);
   params->SetInteger("xDistance", 0);
   params->SetInteger("yDistance", -100);
   SendCommand("Input.synthesizeScrollGesture", std::move(params));
 
   ASSERT_TRUE(content::ExecuteScriptAndExtractInt(
       shell()->web_contents(),
       "domAutomationController.send(document.body.scrollTop)", &scroll_top));
   ASSERT_EQ(100, scroll_top);
 }
 
 IN_PROC_BROWSER_TEST_F(DevToolsProtocolTest, DISABLED_SynthesizeTapGesture) {
   GURL test_url = GetTestUrl("devtools", "synthetic_gesture_tests.html");
   NavigateToURLBlockUntilNavigationsComplete(shell(), test_url, 1);
   Attach();
 
   int scroll_top;
   ASSERT_TRUE(content::ExecuteScriptAndExtractInt(
       shell()->web_contents(),
       "domAutomationController.send(document.body.scrollTop)", &scroll_top));
   ASSERT_EQ(0, scroll_top);
 
-  scoped_ptr<base::DictionaryValue> params(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> params(new base::DictionaryValue());
   params->SetInteger("x", 16);
   params->SetInteger("y", 16);
   params->SetString("gestureSourceType", "touch");
   SendCommand("Input.synthesizeTapGesture", std::move(params));
 
   // The link that we just tapped should take us to the bottom of the page. The
   // new value of |document.body.scrollTop| will depend on the screen dimensions
   // of the device that we're testing on, but in any case it should be greater
   // than 0.
   ASSERT_TRUE(content::ExecuteScriptAndExtractInt(
       shell()->web_contents(),
       "domAutomationController.send(document.body.scrollTop)", &scroll_top));
   ASSERT_GT(scroll_top, 0);
 }
 #endif  // defined(OS_ANDROID)
 
 IN_PROC_BROWSER_TEST_F(DevToolsProtocolTest, NavigationPreservesMessages) {
   ASSERT_TRUE(embedded_test_server()->Start());
   GURL test_url = embedded_test_server()->GetURL("/devtools/navigation.html");
   NavigateToURLBlockUntilNavigationsComplete(shell(), test_url, 1);
   Attach();
   SendCommand("Page.enable", nullptr, false);
 
-  scoped_ptr<base::DictionaryValue> params(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> params(new base::DictionaryValue());
   test_url = GetTestUrl("devtools", "navigation.html");
   params->SetString("url", test_url.spec());
   TestNavigationObserver navigation_observer(shell()->web_contents());
   SendCommand("Page.navigate", std::move(params), true);
   navigation_observer.Wait();
 
   bool enough_results = result_ids_.size() >= 2u;
   EXPECT_TRUE(enough_results);
   if (enough_results) {
     EXPECT_EQ(1, result_ids_[0]);  // Page.enable
@@ skipping 129 matching lines @@
       gfx::Size());
   WaitForLoadStop(window->web_contents());
   Attach();
   SendCommand("Page.reload", nullptr, false);
   // Should not crash at this point.
 }
 
 IN_PROC_BROWSER_TEST_F(DevToolsProtocolTest, EvaluateInBlankPage) {
   NavigateToURLBlockUntilNavigationsComplete(shell(), GURL("about:blank"), 1);
   Attach();
-  scoped_ptr<base::DictionaryValue> params(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> params(new base::DictionaryValue());
   params->SetString("expression", "window");
   SendCommand("Runtime.evaluate", std::move(params), true);
   bool wasThrown = true;
   EXPECT_TRUE(result_->GetBoolean("wasThrown", &wasThrown));
   EXPECT_FALSE(wasThrown);
 }
 
 IN_PROC_BROWSER_TEST_F(DevToolsProtocolTest,
     EvaluateInBlankPageAfterNavigation) {
   ASSERT_TRUE(embedded_test_server()->Start());
   GURL test_url = embedded_test_server()->GetURL("/devtools/navigation.html");
   NavigateToURLBlockUntilNavigationsComplete(shell(), test_url, 1);
   Attach();
   NavigateToURLBlockUntilNavigationsComplete(shell(), GURL("about:blank"), 1);
-  scoped_ptr<base::DictionaryValue> params(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> params(new base::DictionaryValue());
   params->SetString("expression", "window");
   SendCommand("Runtime.evaluate", std::move(params), true);
   bool wasThrown = true;
   EXPECT_TRUE(result_->GetBoolean("wasThrown", &wasThrown));
   EXPECT_FALSE(wasThrown);
 }
 
 }  // namespace content