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

content/renderer/mus/compositor_mus_connection_unittest.cc

 // Copyright 2016 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 "content/renderer/mus/compositor_mus_connection.h"
 
+#include <memory>
+
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/time/time.h"
 #include "components/mus/public/cpp/tests/test_window.h"
 #include "components/mus/public/interfaces/input_event_constants.mojom.h"
 #include "components/mus/public/interfaces/input_events.mojom.h"
 #include "components/mus/public/interfaces/input_key_codes.mojom.h"
 #include "content/common/input/did_overscroll_params.h"
 #include "content/common/input/input_event_ack.h"
 #include "content/common/input/input_event_ack_state.h"
 #include "content/public/test/mock_render_thread.h"
@@ skipping 163 matching lines @@
     content::RenderWidget* render_widget)
     : content::RenderWidgetInputHandler(render_widget, render_widget),
       delegate_(nullptr),
       state_(content::InputEventAckState::INPUT_EVENT_ACK_STATE_UNKNOWN) {}
 
 void TestRenderWidgetInputHandler::HandleInputEvent(
     const blink::WebInputEvent& input_event,
     const ui::LatencyInfo& latency_info,
     content::InputEventDispatchType dispatch_type) {
   if (delegate_) {
-    scoped_ptr<content::InputEventAck> ack(
+    std::unique_ptr<content::InputEventAck> ack(
         new content::InputEventAck(input_event.type, state_));
     delegate_->OnInputEventAck(std::move(ack));
   }
 }
 
 }  // namespace
 
 namespace content {
 
 // Test suite for CompositorMusConnection, this does not setup a full renderer
 // environment. This does not establish a connection to a mus server, nor does
 // it initialize one.
 class CompositorMusConnectionTest : public testing::Test {
  public:
   CompositorMusConnectionTest() {}
   ~CompositorMusConnectionTest() override {}
 
   // Returns a valid key event, so that it can be converted to a web event by
   // CompositorMusConnection.
-  scoped_ptr<ui::Event> GenerateKeyEvent();
+  std::unique_ptr<ui::Event> GenerateKeyEvent();
 
   // Calls CompositorMusConnection::OnWindowInputEvent.
-  void OnWindowInputEvent(mus::Window* window,
-                          const ui::Event& event,
-                          scoped_ptr<base::Callback<void(bool)>>* ack_callback);
+  void OnWindowInputEvent(
+      mus::Window* window,
+      const ui::Event& event,
+      std::unique_ptr<base::Callback<void(bool)>>* ack_callback);
 
   // Confirms the state of pending tasks enqueued on each task runner, and runs
   // until idle.
   void VerifyAndRunQueues(bool main_task_runner_enqueued,
                           bool compositor_task_runner_enqueued);
 
   CompositorMusConnection* compositor_connection() {
     return compositor_connection_.get();
   }
   RenderWidgetMusConnection* connection() { return connection_; }
@@ skipping 22 matching lines @@
   RenderWidgetMusConnection* connection_;
 
   // Test versions of task runners, see VerifyAndRunQueues to use in testing.
   scoped_refptr<base::TestSimpleTaskRunner> main_task_runner_;
   scoped_refptr<base::TestSimpleTaskRunner> compositor_task_runner_;
 
   // Actual CompositorMusConnection for testing.
   scoped_refptr<CompositorMusConnection> compositor_connection_;
 
   // Test implementations, to control input given to |compositor_connection_|.
-  scoped_ptr<TestInputHandlerManager> input_handler_manager_;
-  scoped_ptr<TestRenderWidgetInputHandler> render_widget_input_handler_;
+  std::unique_ptr<TestInputHandlerManager> input_handler_manager_;
+  std::unique_ptr<TestRenderWidgetInputHandler> render_widget_input_handler_;
 
   DISALLOW_COPY_AND_ASSIGN(CompositorMusConnectionTest);
 };
 
-scoped_ptr<ui::Event> CompositorMusConnectionTest::GenerateKeyEvent() {
-  return scoped_ptr<ui::Event>(new ui::KeyEvent(
+std::unique_ptr<ui::Event> CompositorMusConnectionTest::GenerateKeyEvent() {
+  return std::unique_ptr<ui::Event>(new ui::KeyEvent(
       ui::ET_KEY_PRESSED, ui::KeyboardCode::VKEY_A, ui::EF_NONE));
 }
 
 void CompositorMusConnectionTest::OnWindowInputEvent(
     mus::Window* window,
     const ui::Event& event,
-    scoped_ptr<base::Callback<void(bool)>>* ack_callback) {
+    std::unique_ptr<base::Callback<void(bool)>>* ack_callback) {
   compositor_connection_->OnWindowInputEvent(window, event, ack_callback);
 }
 
 void CompositorMusConnectionTest::VerifyAndRunQueues(
     bool main_task_runner_enqueued,
     bool compositor_task_runner_enqueued) {
   // Run through the enqueued actions.
   EXPECT_EQ(main_task_runner_enqueued, main_task_runner_->HasPendingTask());
   main_task_runner_->RunUntilIdle();
 
@@ skipping 37 matching lines @@
 // Tests that for events which the renderer will ack, yet not consume, that
 // CompositorMusConnection consumes the ack during OnWindowInputEvent, and calls
 // it with the correct state once processed.
 TEST_F(CompositorMusConnectionTest, NotConsumed) {
   TestRenderWidgetInputHandler* input_handler = render_widget_input_handler();
   input_handler->set_delegate(connection());
   input_handler->set_state(
       InputEventAckState::INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 
   mus::TestWindow test_window;
-  scoped_ptr<ui::Event> event(GenerateKeyEvent());
+  std::unique_ptr<ui::Event> event(GenerateKeyEvent());
   scoped_refptr<TestCallback> test_callback(new TestCallback);
-  scoped_ptr<base::Callback<void(bool)>> ack_callback(
+  std::unique_ptr<base::Callback<void(bool)>> ack_callback(
       new base::Callback<void(bool)>(
           base::Bind(&::TestCallback::BoolCallback, test_callback)));
 
   OnWindowInputEvent(&test_window, *event.get(), &ack_callback);
   // OnWindowInputEvent is expected to clear the callback if it plans on
   // handling the ack.
   EXPECT_FALSE(ack_callback.get());
 
   VerifyAndRunQueues(true, true);
 
   // The ack callback should have been called
   EXPECT_TRUE(test_callback->called());
   EXPECT_FALSE(test_callback->result());
 }
 
 // Tests that for events which the renderer will ack, and consume, that
 // CompositorMusConnection consumes the ack during OnWindowInputEvent, and calls
 // it with the correct state once processed.
 TEST_F(CompositorMusConnectionTest, Consumed) {
   TestRenderWidgetInputHandler* input_handler = render_widget_input_handler();
   input_handler->set_delegate(connection());
   input_handler->set_state(InputEventAckState::INPUT_EVENT_ACK_STATE_CONSUMED);
 
   mus::TestWindow test_window;
-  scoped_ptr<ui::Event> event(GenerateKeyEvent());
+  std::unique_ptr<ui::Event> event(GenerateKeyEvent());
   scoped_refptr<TestCallback> test_callback(new TestCallback);
-  scoped_ptr<base::Callback<void(bool)>> ack_callback(
+  std::unique_ptr<base::Callback<void(bool)>> ack_callback(
       new base::Callback<void(bool)>(
           base::Bind(&::TestCallback::BoolCallback, test_callback)));
 
   OnWindowInputEvent(&test_window, *event.get(), &ack_callback);
   // OnWindowInputEvent is expected to clear the callback if it plans on
   // handling the ack.
   EXPECT_FALSE(ack_callback.get());
 
   VerifyAndRunQueues(true, true);
 
   // The ack callback should have been called
   EXPECT_TRUE(test_callback->called());
   EXPECT_TRUE(test_callback->result());
 }
 
 // Tests that when the RenderWidgetInputHandler does not ack before a new event
 // arrives, that only the most recent ack is fired.
 TEST_F(CompositorMusConnectionTest, LostAck) {
   mus::TestWindow test_window;
-  scoped_ptr<ui::Event> event1(GenerateKeyEvent());
+  std::unique_ptr<ui::Event> event1(GenerateKeyEvent());
   scoped_refptr<TestCallback> test_callback1(new TestCallback);
-  scoped_ptr<base::Callback<void(bool)>> ack_callback1(
+  std::unique_ptr<base::Callback<void(bool)>> ack_callback1(
       new base::Callback<void(bool)>(
           base::Bind(&::TestCallback::BoolCallback, test_callback1)));
 
   OnWindowInputEvent(&test_window, *event1.get(), &ack_callback1);
   EXPECT_FALSE(ack_callback1.get());
   // When simulating the timeout the ack is never enqueued
   VerifyAndRunQueues(true, false);
 
   // Setting a delegate will lead to the next event being acked. Having a
   // cleared queue simulates the input handler timing out on an event.
   TestRenderWidgetInputHandler* input_handler = render_widget_input_handler();
   input_handler->set_delegate(connection());
   input_handler->set_state(InputEventAckState::INPUT_EVENT_ACK_STATE_CONSUMED);
 
-  scoped_ptr<ui::Event> event2(GenerateKeyEvent());
+  std::unique_ptr<ui::Event> event2(GenerateKeyEvent());
   scoped_refptr<TestCallback> test_callback2(new TestCallback);
-  scoped_ptr<base::Callback<void(bool)>> ack_callback2(
+  std::unique_ptr<base::Callback<void(bool)>> ack_callback2(
       new base::Callback<void(bool)>(
           base::Bind(&::TestCallback::BoolCallback, test_callback2)));
   OnWindowInputEvent(&test_window, *event2.get(), &ack_callback2);
   EXPECT_FALSE(ack_callback2.get());
 
   VerifyAndRunQueues(true, true);
 
   // Only the most recent ack was called.
   EXPECT_FALSE(test_callback1->called());
   EXPECT_TRUE(test_callback2->called());
   EXPECT_TRUE(test_callback2->result());
 }
 
 // Tests that when an input handler consumes the event, that
 // CompositorMusConnection does not consume the ack, nor calls it.
 TEST_F(CompositorMusConnectionTest, InputHandlerConsumes) {
   input_handler_manager()->SetHandleInputEventResult(
       InputEventAckState::INPUT_EVENT_ACK_STATE_CONSUMED);
   mus::TestWindow test_window;
-  scoped_ptr<ui::Event> event(GenerateKeyEvent());
+  std::unique_ptr<ui::Event> event(GenerateKeyEvent());
   scoped_refptr<TestCallback> test_callback(new TestCallback);
-  scoped_ptr<base::Callback<void(bool)>> ack_callback(
+  std::unique_ptr<base::Callback<void(bool)>> ack_callback(
       new base::Callback<void(bool)>(
           base::Bind(&::TestCallback::BoolCallback, test_callback)));
 
   OnWindowInputEvent(&test_window, *event.get(), &ack_callback);
 
   EXPECT_TRUE(ack_callback.get());
   VerifyAndRunQueues(false, false);
   EXPECT_FALSE(test_callback->called());
 }
 
 // Tests that when the renderer will not ack an event, that
 // CompositorMusConnection does not consume the ack, nor calls it.
 TEST_F(CompositorMusConnectionTest, RendererWillNotSendAck) {
   mus::TestWindow test_window;
   ui::PointerEvent event(ui::ET_POINTER_DOWN,
                          ui::EventPointerType::POINTER_TYPE_MOUSE, gfx::Point(),
                          gfx::Point(), ui::EF_NONE, 0, ui::EventTimeForNow());
 
   scoped_refptr<TestCallback> test_callback(new TestCallback);
-  scoped_ptr<base::Callback<void(bool)>> ack_callback(
+  std::unique_ptr<base::Callback<void(bool)>> ack_callback(
       new base::Callback<void(bool)>(
           base::Bind(&::TestCallback::BoolCallback, test_callback)));
 
   OnWindowInputEvent(&test_window, event, &ack_callback);
   EXPECT_TRUE(ack_callback.get());
 
   VerifyAndRunQueues(true, false);
   EXPECT_FALSE(test_callback->called());
 }
 
 }  // namespace content