Convert //chrome/browser/chromeos from scoped_ptr to std::unique_ptr

chrome/browser/chromeos/events/event_rewriter_unittest.cc

 // Copyright 2014 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 "chrome/browser/chromeos/events/event_rewriter.h"
 
 #include <vector>
 
 #include "ash/shell.h"
 #include "ash/sticky_keys/sticky_keys_controller.h"
@@ skipping 60 matching lines @@
 }
 
 std::string GetRewrittenEventAsString(chromeos::EventRewriter* rewriter,
                                       ui::EventType ui_type,
                                       ui::KeyboardCode ui_keycode,
                                       ui::DomCode code,
                                       int ui_flags,  // ui::EventFlags
                                       ui::DomKey key) {
   const ui::KeyEvent event(ui_type, ui_keycode, code, ui_flags, key,
                            ui::EventTimeForNow());
-  scoped_ptr<ui::Event> new_event;
+  std::unique_ptr<ui::Event> new_event;
   rewriter->RewriteEvent(event, &new_event);
   if (new_event)
     return GetKeyEventAsString(*new_event->AsKeyEvent());
   return GetKeyEventAsString(event);
 }
 
 // Table entry for simple single key event rewriting tests.
 struct KeyTestCase {
   ui::EventType type;
   struct Event {
@@ skipping 47 matching lines @@
     chromeos::input_method::Shutdown();
   }
 
  protected:
   void TestRewriteNumPadKeys();
   void TestRewriteNumPadKeysOnAppleKeyboard();
 
   const ui::MouseEvent* RewriteMouseButtonEvent(
       chromeos::EventRewriter* rewriter,
       const ui::MouseEvent& event,
-      scoped_ptr<ui::Event>* new_event) {
+      std::unique_ptr<ui::Event>* new_event) {
     rewriter->RewriteMouseButtonEventForTesting(event, new_event);
     return *new_event ? new_event->get()->AsMouseEvent() : &event;
   }
 
   user_manager::FakeUserManager* fake_user_manager_;  // Not owned.
   chromeos::ScopedUserManagerEnabler user_manager_enabler_;
   chromeos::input_method::MockInputMethodManager* input_method_manager_mock_;
 };
 
 TEST_F(EventRewriterTest, TestRewriteCommandToControl) {
@@ skipping 1655 matching lines @@
 
   EventRewriter rewriter(NULL);
   rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
   rewriter.set_pref_service_for_testing(&prefs);
 
   // Send left control press.
   {
     ui::KeyEvent keyevent(ui::ET_KEY_PRESSED, ui::VKEY_CONTROL,
                           ui::DomCode::CONTROL_LEFT, ui::EF_FINAL,
                           ui::DomKey::CONTROL, ui::EventTimeForNow());
-    scoped_ptr<ui::Event> new_event;
+    std::unique_ptr<ui::Event> new_event;
     // Control should NOT be remapped to Alt if EF_FINAL is set.
     EXPECT_EQ(ui::EVENT_REWRITE_CONTINUE,
               rewriter.RewriteEvent(keyevent, &new_event));
     EXPECT_FALSE(new_event);
   }
 #if defined(USE_X11)
   // Send left control press, using XI2 native events.
   {
     ui::ScopedXI2Event xev;
     xev.InitKeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_CONTROL, 0);
     XEvent* xevent = xev;
     xevent->xkey.keycode = XKeysymToKeycode(gfx::GetXDisplay(), XK_Control_L);
     xevent->xkey.send_event = True;  // XSendEvent() always does this.
     ui::KeyEvent keyevent(xev);
-    scoped_ptr<ui::Event> new_event;
+    std::unique_ptr<ui::Event> new_event;
     // Control should NOT be remapped to Alt if send_event
     // flag in the event is True.
     EXPECT_EQ(ui::EVENT_REWRITE_CONTINUE,
               rewriter.RewriteEvent(keyevent, &new_event));
     EXPECT_FALSE(new_event);
   }
 #endif
 }
 
 TEST_F(EventRewriterTest, TestRewriteNonNativeEvent) {
@@ skipping 10 matching lines @@
 
   const int kTouchId = 2;
   gfx::Point location(0, 0);
   ui::TouchEvent press(ui::ET_TOUCH_PRESSED, location, kTouchId,
                        base::TimeDelta());
   press.set_flags(ui::EF_CONTROL_DOWN);
 #if defined(USE_X11)
   ui::UpdateX11EventForFlags(&press);
 #endif
 
-  scoped_ptr<ui::Event> new_event;
+  std::unique_ptr<ui::Event> new_event;
   rewriter.RewriteEvent(press, &new_event);
   EXPECT_TRUE(new_event);
   // Control should be remapped to Alt.
   EXPECT_EQ(ui::EF_ALT_DOWN,
             new_event->flags() & (ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN));
 }
 
 // Keeps a buffer of handled events.
 class EventBuffer : public ui::test::TestEventProcessor {
  public:
@@ skipping 34 matching lines @@
 // Tests of event rewriting that depend on the Ash window manager.
 class EventRewriterAshTest : public ash::test::AshTestBase {
  public:
   EventRewriterAshTest()
       : source_(&buffer_),
         fake_user_manager_(new user_manager::FakeUserManager),
         user_manager_enabler_(fake_user_manager_) {}
   ~EventRewriterAshTest() override {}
 
   bool RewriteFunctionKeys(const ui::Event& event,
-                           scoped_ptr<ui::Event>* rewritten_event) {
+                           std::unique_ptr<ui::Event>* rewritten_event) {
     return rewriter_->RewriteEvent(event, rewritten_event);
   }
 
   ui::EventDispatchDetails Send(ui::Event* event) {
     return source_.Send(event);
   }
 
   void SendKeyEvent(ui::EventType type,
                     ui::KeyboardCode key_code,
                     ui::DomCode code,
@@ skipping 32 matching lines @@
 
   void TearDown() override {
     rewriter_.reset();
     AshTestBase::TearDown();
   }
 
  protected:
   ash::StickyKeysController* sticky_keys_controller_;
 
  private:
-  scoped_ptr<EventRewriter> rewriter_;
+  std::unique_ptr<EventRewriter> rewriter_;
 
   EventBuffer buffer_;
   TestEventSource source_;
 
   user_manager::FakeUserManager* fake_user_manager_;  // Not owned.
   chromeos::ScopedUserManagerEnabler user_manager_enabler_;
   syncable_prefs::TestingPrefServiceSyncable prefs_;
 
   DISALLOW_COPY_AND_ASSIGN(EventRewriterAshTest);
 };
 
 TEST_F(EventRewriterAshTest, TopRowKeysAreFunctionKeys) {
-  scoped_ptr<aura::Window> window(CreateTestWindowInShellWithId(1));
+  std::unique_ptr<aura::Window> window(CreateTestWindowInShellWithId(1));
   ash::wm::WindowState* window_state = ash::wm::GetWindowState(window.get());
   window_state->Activate();
   ScopedVector<ui::Event> events;
 
   // Create a simulated keypress of F1 targetted at the window.
   ui::KeyEvent press_f1(ui::ET_KEY_PRESSED, ui::VKEY_F1, ui::DomCode::F1,
                         ui::EF_NONE, ui::DomKey::F1, ui::EventTimeForNow());
 
   // Simulate an apps v2 window that has requested top row keys as function
   // keys. The event should not be rewritten.
@@ skipping 54 matching lines @@
 
   // Check that Control + Left Button is converted (via Alt + Left Button)
   // to Right Button.
   ui::ScopedXI2Event xev;
   xev.InitGenericButtonEvent(10, ui::ET_MOUSE_PRESSED, gfx::Point(),
                              ui::EF_LEFT_MOUSE_BUTTON | ui::EF_CONTROL_DOWN);
   ui::MouseEvent press(xev);
   // Sanity check.
   EXPECT_EQ(ui::ET_MOUSE_PRESSED, press.type());
   EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON | ui::EF_CONTROL_DOWN, press.flags());
-  scoped_ptr<ui::Event> new_event;
+  std::unique_ptr<ui::Event> new_event;
   const ui::MouseEvent* result =
       RewriteMouseButtonEvent(&rewriter, press, &new_event);
   EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result->flags());
   EXPECT_FALSE(ui::EF_LEFT_MOUSE_BUTTON & result->flags());
   EXPECT_FALSE(ui::EF_CONTROL_DOWN & result->flags());
   EXPECT_FALSE(ui::EF_ALT_DOWN & result->flags());
   EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result->flags());
 #endif
 }
 
@@ skipping 14 matching lines @@
   // Test Alt + Left click.
   {
     ui::MouseEvent press(ui::ET_MOUSE_PRESSED, gfx::Point(), gfx::Point(),
                          ui::EventTimeForNow(), kLeftAndAltFlag,
                          ui::EF_LEFT_MOUSE_BUTTON);
     ui::EventTestApi test_press(&press);
     test_press.set_source_device_id(10);
     // Sanity check.
     EXPECT_EQ(ui::ET_MOUSE_PRESSED, press.type());
     EXPECT_EQ(kLeftAndAltFlag, press.flags());
-    scoped_ptr<ui::Event> new_event;
+    std::unique_ptr<ui::Event> new_event;
     const ui::MouseEvent* result =
         RewriteMouseButtonEvent(&rewriter, press, &new_event);
     EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result->flags());
     EXPECT_FALSE(kLeftAndAltFlag & result->flags());
     EXPECT_EQ(ui::EF_RIGHT_MOUSE_BUTTON, result->changed_button_flags());
   }
   {
     ui::MouseEvent release(ui::ET_MOUSE_RELEASED, gfx::Point(), gfx::Point(),
                            ui::EventTimeForNow(), kLeftAndAltFlag,
                            ui::EF_LEFT_MOUSE_BUTTON);
     ui::EventTestApi test_release(&release);
     test_release.set_source_device_id(10);
-    scoped_ptr<ui::Event> new_event;
+    std::unique_ptr<ui::Event> new_event;
     const ui::MouseEvent* result =
         RewriteMouseButtonEvent(&rewriter, release, &new_event);
     EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result->flags());
     EXPECT_FALSE(kLeftAndAltFlag & result->flags());
     EXPECT_EQ(ui::EF_RIGHT_MOUSE_BUTTON, result->changed_button_flags());
   }
 #if defined(USE_X11)
   // Test Alt + Left click, using XI2 native events.
   {
     ui::ScopedXI2Event xev;
     xev.InitGenericButtonEvent(10, ui::ET_MOUSE_PRESSED, gfx::Point(),
                                kLeftAndAltFlag);
     ui::MouseEvent press(xev);
     // Sanity check.
     EXPECT_EQ(ui::ET_MOUSE_PRESSED, press.type());
     EXPECT_EQ(kLeftAndAltFlag, press.flags());
-    scoped_ptr<ui::Event> new_event;
+    std::unique_ptr<ui::Event> new_event;
     const ui::MouseEvent* result =
         RewriteMouseButtonEvent(&rewriter, press, &new_event);
     EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result->flags());
     EXPECT_FALSE(kLeftAndAltFlag & result->flags());
     EXPECT_EQ(ui::EF_RIGHT_MOUSE_BUTTON, result->changed_button_flags());
   }
   {
     ui::ScopedXI2Event xev;
     xev.InitGenericButtonEvent(10, ui::ET_MOUSE_RELEASED, gfx::Point(),
                                kLeftAndAltFlag);
     ui::MouseEvent release(xev);
-    scoped_ptr<ui::Event> new_event;
+    std::unique_ptr<ui::Event> new_event;
     const ui::MouseEvent* result =
         RewriteMouseButtonEvent(&rewriter, release, &new_event);
     EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result->flags());
     EXPECT_FALSE(kLeftAndAltFlag & result->flags());
     EXPECT_EQ(ui::EF_RIGHT_MOUSE_BUTTON, result->changed_button_flags());
   }
 #endif
 
   // No ALT in frst click.
   {
     ui::MouseEvent press(ui::ET_MOUSE_PRESSED, gfx::Point(), gfx::Point(),
                          ui::EventTimeForNow(), ui::EF_LEFT_MOUSE_BUTTON,
                          ui::EF_LEFT_MOUSE_BUTTON);
     ui::EventTestApi test_press(&press);
     test_press.set_source_device_id(10);
-    scoped_ptr<ui::Event> new_event;
+    std::unique_ptr<ui::Event> new_event;
     const ui::MouseEvent* result =
         RewriteMouseButtonEvent(&rewriter, press, &new_event);
     EXPECT_TRUE(ui::EF_LEFT_MOUSE_BUTTON & result->flags());
     EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON, result->changed_button_flags());
   }
   {
     ui::MouseEvent release(ui::ET_MOUSE_RELEASED, gfx::Point(), gfx::Point(),
                            ui::EventTimeForNow(), kLeftAndAltFlag,
                            ui::EF_LEFT_MOUSE_BUTTON);
     ui::EventTestApi test_release(&release);
     test_release.set_source_device_id(10);
-    scoped_ptr<ui::Event> new_event;
+    std::unique_ptr<ui::Event> new_event;
     const ui::MouseEvent* result =
         RewriteMouseButtonEvent(&rewriter, release, &new_event);
     EXPECT_TRUE((ui::EF_LEFT_MOUSE_BUTTON | ui::EF_ALT_DOWN) & result->flags());
     EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON, result->changed_button_flags());
   }
 #if defined(USE_X11)
   // No ALT in frst click, using XI2 native events.
   {
     ui::ScopedXI2Event xev;
     xev.InitGenericButtonEvent(10, ui::ET_MOUSE_PRESSED, gfx::Point(),
                                ui::EF_LEFT_MOUSE_BUTTON);
     ui::MouseEvent press(xev);
-    scoped_ptr<ui::Event> new_event;
+    std::unique_ptr<ui::Event> new_event;
     const ui::MouseEvent* result =
         RewriteMouseButtonEvent(&rewriter, press, &new_event);
     EXPECT_TRUE(ui::EF_LEFT_MOUSE_BUTTON & result->flags());
     EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON, result->changed_button_flags());
   }
   {
     ui::ScopedXI2Event xev;
     xev.InitGenericButtonEvent(10, ui::ET_MOUSE_RELEASED, gfx::Point(),
                                kLeftAndAltFlag);
     ui::MouseEvent release(xev);
-    scoped_ptr<ui::Event> new_event;
+    std::unique_ptr<ui::Event> new_event;
     const ui::MouseEvent* result =
         RewriteMouseButtonEvent(&rewriter, release, &new_event);
     EXPECT_TRUE((ui::EF_LEFT_MOUSE_BUTTON | ui::EF_ALT_DOWN) & result->flags());
     EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON, result->changed_button_flags());
   }
 #endif
 
   // ALT on different device.
   {
     ui::MouseEvent press(ui::ET_MOUSE_PRESSED, gfx::Point(), gfx::Point(),
                          ui::EventTimeForNow(), kLeftAndAltFlag,
                          ui::EF_LEFT_MOUSE_BUTTON);
     ui::EventTestApi test_press(&press);
     test_press.set_source_device_id(11);
-    scoped_ptr<ui::Event> new_event;
+    std::unique_ptr<ui::Event> new_event;
     const ui::MouseEvent* result =
         RewriteMouseButtonEvent(&rewriter, press, &new_event);
     EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result->flags());
     EXPECT_FALSE(kLeftAndAltFlag & result->flags());
     EXPECT_EQ(ui::EF_RIGHT_MOUSE_BUTTON, result->changed_button_flags());
   }
   {
     ui::MouseEvent release(ui::ET_MOUSE_RELEASED, gfx::Point(), gfx::Point(),
                            ui::EventTimeForNow(), kLeftAndAltFlag,
                            ui::EF_LEFT_MOUSE_BUTTON);
     ui::EventTestApi test_release(&release);
     test_release.set_source_device_id(10);
-    scoped_ptr<ui::Event> new_event;
+    std::unique_ptr<ui::Event> new_event;
     const ui::MouseEvent* result =
         RewriteMouseButtonEvent(&rewriter, release, &new_event);
     EXPECT_TRUE((ui::EF_LEFT_MOUSE_BUTTON | ui::EF_ALT_DOWN) & result->flags());
     EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON, result->changed_button_flags());
   }
   {
     ui::MouseEvent release(ui::ET_MOUSE_RELEASED, gfx::Point(), gfx::Point(),
                            ui::EventTimeForNow(), kLeftAndAltFlag,
                            ui::EF_LEFT_MOUSE_BUTTON);
     ui::EventTestApi test_release(&release);
     test_release.set_source_device_id(11);
-    scoped_ptr<ui::Event> new_event;
+    std::unique_ptr<ui::Event> new_event;
     const ui::MouseEvent* result =
         RewriteMouseButtonEvent(&rewriter, release, &new_event);
     EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result->flags());
     EXPECT_FALSE(kLeftAndAltFlag & result->flags());
     EXPECT_EQ(ui::EF_RIGHT_MOUSE_BUTTON, result->changed_button_flags());
   }
 #if defined(USE_X11)
   // ALT on different device, using XI2 native events.
   {
     ui::ScopedXI2Event xev;
     xev.InitGenericButtonEvent(11, ui::ET_MOUSE_PRESSED, gfx::Point(),
                                kLeftAndAltFlag);
     ui::MouseEvent press(xev);
-    scoped_ptr<ui::Event> new_event;
+    std::unique_ptr<ui::Event> new_event;
     const ui::MouseEvent* result =
         RewriteMouseButtonEvent(&rewriter, press, &new_event);
     EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result->flags());
     EXPECT_FALSE(kLeftAndAltFlag & result->flags());
     EXPECT_EQ(ui::EF_RIGHT_MOUSE_BUTTON, result->changed_button_flags());
   }
   {
     ui::ScopedXI2Event xev;
     xev.InitGenericButtonEvent(10, ui::ET_MOUSE_RELEASED, gfx::Point(),
                                kLeftAndAltFlag);
     ui::MouseEvent release(xev);
-    scoped_ptr<ui::Event> new_event;
+    std::unique_ptr<ui::Event> new_event;
     const ui::MouseEvent* result =
         RewriteMouseButtonEvent(&rewriter, release, &new_event);
     EXPECT_TRUE((ui::EF_LEFT_MOUSE_BUTTON | ui::EF_ALT_DOWN) & result->flags());
     EXPECT_EQ(ui::EF_LEFT_MOUSE_BUTTON, result->changed_button_flags());
   }
   {
     ui::ScopedXI2Event xev;
     xev.InitGenericButtonEvent(11, ui::ET_MOUSE_RELEASED, gfx::Point(),
                                kLeftAndAltFlag);
     ui::MouseEvent release(xev);
-    scoped_ptr<ui::Event> new_event;
+    std::unique_ptr<ui::Event> new_event;
     const ui::MouseEvent* result =
         RewriteMouseButtonEvent(&rewriter, release, &new_event);
     EXPECT_TRUE(ui::EF_RIGHT_MOUSE_BUTTON & result->flags());
     EXPECT_FALSE(kLeftAndAltFlag & result->flags());
     EXPECT_EQ(ui::EF_RIGHT_MOUSE_BUTTON, result->changed_button_flags());
   }
 #endif
 }
 
 TEST_F(EventRewriterAshTest, StickyKeyEventDispatchImpl) {
@@ skipping 319 matching lines @@
   EXPECT_FALSE(overlay_->GetModifierVisible(ui::EF_ALTGR_DOWN));
   EXPECT_TRUE(overlay_->GetModifierVisible(ui::EF_MOD3_DOWN));
 
   // Turn off AltGr and Mod3.
   sticky_keys_controller_->SetModifiersEnabled(false, false);
   EXPECT_FALSE(overlay_->GetModifierVisible(ui::EF_ALTGR_DOWN));
   EXPECT_FALSE(overlay_->GetModifierVisible(ui::EF_MOD3_DOWN));
 }
 
 }  // namespace chromeos