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

chrome/browser/chromeos/events/event_rewriter.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 <stddef.h>
 
 #include <vector>
 
@@ skipping 297 matching lines @@
     int device_id,
     const std::string& device_name) {
   // Tests must avoid XI2 reserved device IDs.
   DCHECK((device_id < 0) || (device_id > 1));
   return KeyboardDeviceAddedInternal(device_id, device_name, kUnknownVendorId,
                                      kUnknownProductId);
 }
 
 void EventRewriter::RewriteMouseButtonEventForTesting(
     const ui::MouseEvent& event,
-    scoped_ptr<ui::Event>* rewritten_event) {
+    std::unique_ptr<ui::Event>* rewritten_event) {
   RewriteMouseButtonEvent(event, rewritten_event);
 }
 
 ui::EventRewriteStatus EventRewriter::RewriteEvent(
     const ui::Event& event,
-    scoped_ptr<ui::Event>* rewritten_event) {
+    std::unique_ptr<ui::Event>* rewritten_event) {
   if ((event.type() == ui::ET_KEY_PRESSED) ||
       (event.type() == ui::ET_KEY_RELEASED)) {
     return RewriteKeyEvent(static_cast<const ui::KeyEvent&>(event),
                            rewritten_event);
   }
   if ((event.type() == ui::ET_MOUSE_PRESSED) ||
       (event.type() == ui::ET_MOUSE_RELEASED)) {
     return RewriteMouseButtonEvent(static_cast<const ui::MouseEvent&>(event),
                                    rewritten_event);
   }
   if (event.type() == ui::ET_MOUSEWHEEL) {
     return RewriteMouseWheelEvent(
         static_cast<const ui::MouseWheelEvent&>(event), rewritten_event);
   }
   if ((event.type() == ui::ET_TOUCH_PRESSED) ||
       (event.type() == ui::ET_TOUCH_RELEASED)) {
     return RewriteTouchEvent(static_cast<const ui::TouchEvent&>(event),
                              rewritten_event);
   }
   if (event.IsScrollEvent()) {
     return RewriteScrollEvent(static_cast<const ui::ScrollEvent&>(event),
                               rewritten_event);
   }
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 ui::EventRewriteStatus EventRewriter::NextDispatchEvent(
     const ui::Event& last_event,
-    scoped_ptr<ui::Event>* new_event) {
+    std::unique_ptr<ui::Event>* new_event) {
   if (sticky_keys_controller_) {
     // In the case of sticky keys, we know what the events obtained here are:
     // modifier key releases that match the ones previously discarded. So, we
     // know that they don't have to be passed through the post-sticky key
     // rewriting phases, |RewriteExtendedKeys()| and |RewriteFunctionKeys()|,
     // because those phases do nothing with modifier key releases.
     return sticky_keys_controller_->NextDispatchEvent(new_event);
   }
   NOTREACHED();
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 void EventRewriter::BuildRewrittenKeyEvent(
     const ui::KeyEvent& key_event,
     const MutableKeyState& state,
-    scoped_ptr<ui::Event>* rewritten_event) {
+    std::unique_ptr<ui::Event>* rewritten_event) {
   ui::KeyEvent* rewritten_key_event =
       new ui::KeyEvent(key_event.type(), state.key_code, state.code,
                        state.flags, state.key, key_event.time_stamp());
   rewritten_event->reset(rewritten_key_event);
 }
 
 void EventRewriter::DeviceKeyPressedOrReleased(int device_id) {
   std::map<int, DeviceType>::const_iterator iter =
       device_id_to_type_.find(device_id);
   DeviceType type;
@@ skipping 97 matching lines @@
     if (remapped_key) {
       unmodified_flags &= ~kModifierRemappings[i].flag;
       rewritten_flags |= remapped_key->flag;
     }
   }
   return rewritten_flags | unmodified_flags;
 }
 
 ui::EventRewriteStatus EventRewriter::RewriteKeyEvent(
     const ui::KeyEvent& key_event,
-    scoped_ptr<ui::Event>* rewritten_event) {
+    std::unique_ptr<ui::Event>* rewritten_event) {
   if (IsExtensionCommandRegistered(key_event.key_code(), key_event.flags()))
     return ui::EVENT_REWRITE_CONTINUE;
   if (key_event.source_device_id() != ui::ED_UNKNOWN_DEVICE)
     DeviceKeyPressedOrReleased(key_event.source_device_id());
 
   // Drop repeated keys from Hotrod remote.
   if ((key_event.flags() & ui::EF_IS_REPEAT) &&
       (key_event.type() == ui::ET_KEY_PRESSED) && IsHotrodRemote() &&
       key_event.key_code() != ui::VKEY_BACK) {
     return ui::EVENT_REWRITE_DISCARD;
@@ skipping 55 matching lines @@
   // might be here because key_event changed, in which case we need to
   // return |EVENT_REWRITE_REWRITTEN|.
   if (status == ui::EVENT_REWRITE_CONTINUE)
     status = ui::EVENT_REWRITE_REWRITTEN;
   BuildRewrittenKeyEvent(key_event, state, rewritten_event);
   return status;
 }
 
 ui::EventRewriteStatus EventRewriter::RewriteMouseButtonEvent(
     const ui::MouseEvent& mouse_event,
-    scoped_ptr<ui::Event>* rewritten_event) {
+    std::unique_ptr<ui::Event>* rewritten_event) {
   int flags = mouse_event.flags();
   RewriteLocatedEvent(mouse_event, &flags);
   ui::EventRewriteStatus status = ui::EVENT_REWRITE_CONTINUE;
   if (sticky_keys_controller_)
     status = sticky_keys_controller_->RewriteMouseEvent(mouse_event, &flags);
   int changed_button = ui::EF_NONE;
   if ((mouse_event.type() == ui::ET_MOUSE_PRESSED) ||
       (mouse_event.type() == ui::ET_MOUSE_RELEASED)) {
     changed_button = RewriteModifierClick(mouse_event, &flags);
   }
@@ skipping 13 matching lines @@
     rewritten_mouse_event->set_changed_button_flags(changed_button);
 #if defined(USE_X11)
     ui::UpdateX11EventForChangedButtonFlags(rewritten_mouse_event);
 #endif
   }
   return status;
 }
 
 ui::EventRewriteStatus EventRewriter::RewriteMouseWheelEvent(
     const ui::MouseWheelEvent& wheel_event,
-    scoped_ptr<ui::Event>* rewritten_event) {
+    std::unique_ptr<ui::Event>* rewritten_event) {
   if (!sticky_keys_controller_)
     return ui::EVENT_REWRITE_CONTINUE;
   int flags = wheel_event.flags();
   ui::EventRewriteStatus status =
       sticky_keys_controller_->RewriteMouseEvent(wheel_event, &flags);
   if ((wheel_event.flags() == flags) &&
       (status == ui::EVENT_REWRITE_CONTINUE)) {
     return ui::EVENT_REWRITE_CONTINUE;
   }
   if (status == ui::EVENT_REWRITE_CONTINUE)
     status = ui::EVENT_REWRITE_REWRITTEN;
   ui::MouseWheelEvent* rewritten_wheel_event =
       new ui::MouseWheelEvent(wheel_event);
   rewritten_event->reset(rewritten_wheel_event);
   rewritten_wheel_event->set_flags(flags);
 #if defined(USE_X11)
   ui::UpdateX11EventForFlags(rewritten_wheel_event);
 #endif
   return status;
 }
 
 ui::EventRewriteStatus EventRewriter::RewriteTouchEvent(
     const ui::TouchEvent& touch_event,
-    scoped_ptr<ui::Event>* rewritten_event) {
+    std::unique_ptr<ui::Event>* rewritten_event) {
   int flags = touch_event.flags();
   RewriteLocatedEvent(touch_event, &flags);
   if (touch_event.flags() == flags)
     return ui::EVENT_REWRITE_CONTINUE;
   ui::TouchEvent* rewritten_touch_event = new ui::TouchEvent(touch_event);
   rewritten_event->reset(rewritten_touch_event);
   rewritten_touch_event->set_flags(flags);
 #if defined(USE_X11)
   ui::UpdateX11EventForFlags(rewritten_touch_event);
 #endif
   return ui::EVENT_REWRITE_REWRITTEN;
 }
 
 ui::EventRewriteStatus EventRewriter::RewriteScrollEvent(
     const ui::ScrollEvent& scroll_event,
-    scoped_ptr<ui::Event>* rewritten_event) {
+    std::unique_ptr<ui::Event>* rewritten_event) {
   int flags = scroll_event.flags();
   ui::EventRewriteStatus status = ui::EVENT_REWRITE_CONTINUE;
   if (sticky_keys_controller_)
     status = sticky_keys_controller_->RewriteScrollEvent(scroll_event, &flags);
   if (status == ui::EVENT_REWRITE_CONTINUE)
     return status;
   ui::ScrollEvent* rewritten_scroll_event = new ui::ScrollEvent(scroll_event);
   rewritten_event->reset(rewritten_scroll_event);
   rewritten_scroll_event->set_flags(flags);
 #if defined(USE_X11)
@@ skipping 497 matching lines @@
   for (const auto& keyboard : keyboards) {
     if (keyboard.id == device_id) {
       return KeyboardDeviceAddedInternal(
           keyboard.id, keyboard.name, keyboard.vendor_id, keyboard.product_id);
     }
   }
   return kDeviceUnknown;
 }
 
 }  // namespace chromeos