Convert //remoting to use std::unique_ptr

remoting/host/it2me/it2me_native_messaging_host_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 "remoting/host/it2me/it2me_native_messaging_host.h"
 
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/compiler_specific.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/stringize_macros.h"
 #include "base/values.h"
 #include "net/base/file_stream.h"
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/native_messaging/log_message_handler.h"
 #include "remoting/host/native_messaging/native_messaging_pipe.h"
 #include "remoting/host/native_messaging/pipe_messaging_channel.h"
 #include "remoting/host/policy_watcher.h"
 #include "remoting/host/setup/test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace remoting {
 
 namespace {
 
 const char kTestAccessCode[] = "888888";
 const int kTestAccessCodeLifetimeInSeconds = 666;
 const char kTestClientUsername[] = "some_user@gmail.com";
 
-void VerifyId(scoped_ptr<base::DictionaryValue> response, int expected_value) {
+void VerifyId(std::unique_ptr<base::DictionaryValue> response,
+              int expected_value) {
   ASSERT_TRUE(response);
 
   int value;
   EXPECT_TRUE(response->GetInteger("id", &value));
   EXPECT_EQ(expected_value, value);
 }
 
-void VerifyStringProperty(scoped_ptr<base::DictionaryValue> response,
+void VerifyStringProperty(std::unique_ptr<base::DictionaryValue> response,
                           const std::string& name,
                           const std::string& expected_value) {
   ASSERT_TRUE(response);
 
   std::string value;
   EXPECT_TRUE(response->GetString(name, &value));
   EXPECT_EQ(expected_value, value);
 }
 
 // Verity the values of the "type" and "id" properties
-void VerifyCommonProperties(scoped_ptr<base::DictionaryValue> response,
+void VerifyCommonProperties(std::unique_ptr<base::DictionaryValue> response,
                             const std::string& type,
                             int id) {
   ASSERT_TRUE(response);
 
   std::string string_value;
   EXPECT_TRUE(response->GetString("type", &string_value));
   EXPECT_EQ(type, string_value);
 
   int int_value;
   EXPECT_TRUE(response->GetInteger("id", &int_value));
   EXPECT_EQ(id, int_value);
 }
 
 }  // namespace
 
 class MockIt2MeHost : public It2MeHost {
  public:
-  MockIt2MeHost(scoped_ptr<ChromotingHostContext> context,
-                scoped_ptr<PolicyWatcher> policy_watcher,
+  MockIt2MeHost(std::unique_ptr<ChromotingHostContext> context,
+                std::unique_ptr<PolicyWatcher> policy_watcher,
                 base::WeakPtr<It2MeHost::Observer> observer,
                 const XmppSignalStrategy::XmppServerConfig& xmpp_server_config,
                 const std::string& directory_bot_jid)
       : It2MeHost(std::move(context),
                   std::move(policy_watcher),
                   nullptr,
                   observer,
                   xmpp_server_config,
                   directory_bot_jid) {}
 
@@ skipping 61 matching lines @@
         FROM_HERE, base::Bind(&It2MeHost::SetStateForTesting, this, state, ""));
   } else {
     SetStateForTesting(state, "");
   }
 }
 
 class MockIt2MeHostFactory : public It2MeHostFactory {
  public:
   MockIt2MeHostFactory() : It2MeHostFactory() {}
   scoped_refptr<It2MeHost> CreateIt2MeHost(
-      scoped_ptr<ChromotingHostContext> context,
+      std::unique_ptr<ChromotingHostContext> context,
       base::WeakPtr<It2MeHost::Observer> observer,
       const XmppSignalStrategy::XmppServerConfig& xmpp_server_config,
       const std::string& directory_bot_jid) override {
     return new MockIt2MeHost(std::move(context), nullptr, observer,
                              xmpp_server_config, directory_bot_jid);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockIt2MeHostFactory);
 };  // MockIt2MeHostFactory
 
 class It2MeNativeMessagingHostTest : public testing::Test {
  public:
   It2MeNativeMessagingHostTest() {}
   ~It2MeNativeMessagingHostTest() override {}
 
   void SetUp() override;
   void TearDown() override;
 
  protected:
-  scoped_ptr<base::DictionaryValue> ReadMessageFromOutputPipe();
+  std::unique_ptr<base::DictionaryValue> ReadMessageFromOutputPipe();
   void WriteMessageToInputPipe(const base::Value& message);
 
   void VerifyHelloResponse(int request_id);
   void VerifyErrorResponse();
   void VerifyConnectResponses(int request_id);
   void VerifyDisconnectResponses(int request_id);
 
   // The Host process should shut down when it receives a malformed request.
   // This is tested by sending a known-good request, followed by |message|,
   // followed by the known-good request again. The response file should only
   // contain a single response from the first good request.
   void TestBadRequest(const base::Value& message, bool expect_error_response);
   void TestConnect();
 
  private:
   void StartHost();
   void ExitTest();
 
   // Each test creates two unidirectional pipes: "input" and "output".
   // It2MeNativeMessagingHost reads from input_read_file and writes to
   // output_write_file. The unittest supplies data to input_write_handle, and
   // verifies output from output_read_handle.
   //
   // unittest -> [input] -> It2MeNativeMessagingHost -> [output] -> unittest
   base::File input_write_file_;
   base::File output_read_file_;
 
   // Message loop of the test thread.
-  scoped_ptr<base::MessageLoop> test_message_loop_;
-  scoped_ptr<base::RunLoop> test_run_loop_;
+  std::unique_ptr<base::MessageLoop> test_message_loop_;
+  std::unique_ptr<base::RunLoop> test_run_loop_;
 
-  scoped_ptr<base::Thread> host_thread_;
-  scoped_ptr<base::RunLoop> host_run_loop_;
+  std::unique_ptr<base::Thread> host_thread_;
+  std::unique_ptr<base::RunLoop> host_run_loop_;
 
   // Task runner of the host thread.
   scoped_refptr<AutoThreadTaskRunner> host_task_runner_;
-  scoped_ptr<remoting::NativeMessagingPipe> pipe_;
+  std::unique_ptr<remoting::NativeMessagingPipe> pipe_;
 
   DISALLOW_COPY_AND_ASSIGN(It2MeNativeMessagingHostTest);
 };
 
 void It2MeNativeMessagingHostTest::SetUp() {
   test_message_loop_.reset(new base::MessageLoop());
   test_run_loop_.reset(new base::RunLoop());
 
   // Run the host on a dedicated thread.
   host_thread_.reset(new base::Thread("host_thread"));
@@ skipping 20 matching lines @@
 
   // Closing the write-end of the input will send an EOF to the native
   // messaging reader. This will trigger a host shutdown.
   input_write_file_.Close();
 
   // Start a new RunLoop and Wait until the host finishes shutting down.
   test_run_loop_.reset(new base::RunLoop());
   test_run_loop_->Run();
 
   // Verify there are no more message in the output pipe.
-  scoped_ptr<base::DictionaryValue> response = ReadMessageFromOutputPipe();
+  std::unique_ptr<base::DictionaryValue> response = ReadMessageFromOutputPipe();
   EXPECT_FALSE(response);
 
   // The It2MeNativeMessagingHost dtor closes the handles that are passed to it.
   // So the only handle left to close is |output_read_file_|.
   output_read_file_.Close();
 }
 
-scoped_ptr<base::DictionaryValue>
+std::unique_ptr<base::DictionaryValue>
 It2MeNativeMessagingHostTest::ReadMessageFromOutputPipe() {
   while (true) {
     uint32_t length;
     int read_result = output_read_file_.ReadAtCurrentPos(
         reinterpret_cast<char*>(&length), sizeof(length));
     if (read_result != sizeof(length)) {
       // The output pipe has been closed, return an empty message.
       return nullptr;
     }
 
     std::string message_json(length, '\0');
     read_result = output_read_file_.ReadAtCurrentPos(
         string_as_array(&message_json), length);
     if (read_result != static_cast<int>(length)) {
       LOG(ERROR) << "Message size (" << read_result
                  << ") doesn't match the header (" << length << ").";
       return nullptr;
     }
 
-    scoped_ptr<base::Value> message = base::JSONReader::Read(message_json);
+    std::unique_ptr<base::Value> message = base::JSONReader::Read(message_json);
     if (!message || !message->IsType(base::Value::TYPE_DICTIONARY)) {
       LOG(ERROR) << "Malformed message:" << message_json;
       return nullptr;
     }
 
-    scoped_ptr<base::DictionaryValue> result = make_scoped_ptr(
+    std::unique_ptr<base::DictionaryValue> result = base::WrapUnique(
         static_cast<base::DictionaryValue*>(message.release()));
     std::string type;
     // If this is a debug message log, ignore it, otherwise return it.
     if (!result->GetString("type", &type) ||
         type != LogMessageHandler::kDebugMessageTypeName) {
       return result;
     }
   }
 }
 
 void It2MeNativeMessagingHostTest::WriteMessageToInputPipe(
     const base::Value& message) {
   std::string message_json;
   base::JSONWriter::Write(message, &message_json);
 
   uint32_t length = message_json.length();
   input_write_file_.WriteAtCurrentPos(reinterpret_cast<char*>(&length),
                                       sizeof(length));
   input_write_file_.WriteAtCurrentPos(message_json.data(), length);
 }
 
 void It2MeNativeMessagingHostTest::VerifyHelloResponse(int request_id) {
-  scoped_ptr<base::DictionaryValue> response = ReadMessageFromOutputPipe();
+  std::unique_ptr<base::DictionaryValue> response = ReadMessageFromOutputPipe();
   VerifyCommonProperties(std::move(response), "helloResponse", request_id);
 }
 
 void It2MeNativeMessagingHostTest::VerifyErrorResponse() {
-  scoped_ptr<base::DictionaryValue> response = ReadMessageFromOutputPipe();
+  std::unique_ptr<base::DictionaryValue> response = ReadMessageFromOutputPipe();
   VerifyStringProperty(std::move(response), "type", "error");
 }
 
 void It2MeNativeMessagingHostTest::VerifyConnectResponses(int request_id) {
   bool connect_response_received = false;
   bool starting_received = false;
   bool requestedAccessCode_received = false;
   bool receivedAccessCode_received = false;
   bool connected_received = false;
 
   // We expect a total of 5 messages: 1 connectResponse and 4 hostStateChanged.
   for (int i = 0; i < 5; ++i) {
-    scoped_ptr<base::DictionaryValue> response = ReadMessageFromOutputPipe();
+    std::unique_ptr<base::DictionaryValue> response =
+        ReadMessageFromOutputPipe();
     ASSERT_TRUE(response);
 
     std::string type;
     ASSERT_TRUE(response->GetString("type", &type));
 
     if (type == "connectResponse") {
       EXPECT_FALSE(connect_response_received);
       connect_response_received = true;
       VerifyId(std::move(response), request_id);
     } else if (type == "hostStateChanged") {
@@ skipping 35 matching lines @@
     }
   }
 }
 
 void It2MeNativeMessagingHostTest::VerifyDisconnectResponses(int request_id) {
   bool disconnect_response_received = false;
   bool disconnected_received = false;
 
   // We expect a total of 3 messages: 1 connectResponse and 1 hostStateChanged.
   for (int i = 0; i < 2; ++i) {
-    scoped_ptr<base::DictionaryValue> response = ReadMessageFromOutputPipe();
+    std::unique_ptr<base::DictionaryValue> response =
+        ReadMessageFromOutputPipe();
     ASSERT_TRUE(response);
 
     std::string type;
     ASSERT_TRUE(response->GetString("type", &type));
 
     if (type == "disconnectResponse") {
       EXPECT_FALSE(disconnect_response_received);
       disconnect_response_received = true;
       VerifyId(std::move(response), request_id);
     } else if (type == "hostStateChanged") {
@@ skipping 19 matching lines @@
 
   WriteMessageToInputPipe(good_message);
   WriteMessageToInputPipe(message);
   WriteMessageToInputPipe(good_message);
 
   VerifyHelloResponse(1);
 
   if (expect_error_response)
     VerifyErrorResponse();
 
-  scoped_ptr<base::DictionaryValue> response = ReadMessageFromOutputPipe();
+  std::unique_ptr<base::DictionaryValue> response = ReadMessageFromOutputPipe();
   EXPECT_FALSE(response);
 }
 
 void It2MeNativeMessagingHostTest::StartHost() {
   DCHECK(host_task_runner_->RunsTasksOnCurrentThread());
 
   base::File input_read_file;
   base::File output_write_file;
 
   ASSERT_TRUE(MakePipe(&input_read_file, &input_write_file_));
   ASSERT_TRUE(MakePipe(&output_read_file_, &output_write_file));
 
   pipe_.reset(new NativeMessagingPipe());
 
-  scoped_ptr<extensions::NativeMessagingChannel> channel(
+  std::unique_ptr<extensions::NativeMessagingChannel> channel(
       new PipeMessagingChannel(std::move(input_read_file),
                                std::move(output_write_file)));
 
   // Creating a native messaging host with a mock It2MeHostFactory.
-  scoped_ptr<extensions::NativeMessageHost> it2me_host(
+  std::unique_ptr<extensions::NativeMessageHost> it2me_host(
       new It2MeNativeMessagingHost(
           ChromotingHostContext::Create(host_task_runner_),
-          make_scoped_ptr(new MockIt2MeHostFactory())));
+          base::WrapUnique(new MockIt2MeHostFactory())));
   it2me_host->Start(pipe_.get());
 
   pipe_->Start(std::move(it2me_host), std::move(channel));
 
   // Notify the test that the host has finished starting up.
   test_message_loop_->task_runner()->PostTask(
       FROM_HERE, test_run_loop_->QuitClosure());
 }
 
 void It2MeNativeMessagingHostTest::ExitTest() {
@@ skipping 43 matching lines @@
 }
 
 // Verify that response ID matches request ID.
 TEST_F(It2MeNativeMessagingHostTest, Id) {
   base::DictionaryValue message;
   message.SetString("type", "hello");
   WriteMessageToInputPipe(message);
   message.SetString("id", "42");
   WriteMessageToInputPipe(message);
 
-  scoped_ptr<base::DictionaryValue> response = ReadMessageFromOutputPipe();
+  std::unique_ptr<base::DictionaryValue> response = ReadMessageFromOutputPipe();
   EXPECT_TRUE(response);
   std::string value;
   EXPECT_FALSE(response->GetString("id", &value));
 
   response = ReadMessageFromOutputPipe();
   EXPECT_TRUE(response);
   EXPECT_TRUE(response->GetString("id", &value));
   EXPECT_EQ("42", value);
 }
 
@@ skipping 19 matching lines @@
 }
 
 // Verify rejection if type is unrecognized.
 TEST_F(It2MeNativeMessagingHostTest, InvalidType) {
   base::DictionaryValue message;
   message.SetString("type", "xxx");
   TestBadRequest(message, true);
 }
 
 }  // namespace remoting