Replace scoped_ptr with std::unique_ptr in //ui

ui/base/ime/chromeos/character_composer_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 "ui/base/ime/chromeos/character_composer.h"
 
 #include <stdint.h>
 
+#include <memory>
+
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/strings/utf_string_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/events/event.h"
 #include "ui/events/event_constants.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/keycodes/dom/dom_code.h"
 #include "ui/events/keycodes/dom/dom_key.h"
 #include "ui/events/keycodes/keyboard_code_conversion.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 
@@ skipping 16 matching lines @@
   KeyEvent* DeadKeyPress(base::char16 combining_character) const {
     KeyEvent* event =
         new KeyEvent(ET_KEY_PRESSED, VKEY_UNKNOWN, DomCode::NONE, EF_NONE,
                      DomKey::DeadKeyFromCombiningCharacter(combining_character),
                      EventTimeForNow());
     return event;
   }
 
   // Expects key is filtered and no character is composed.
   void ExpectDeadKeyFiltered(base::char16 combining_character) {
-    scoped_ptr<KeyEvent> event(DeadKeyPress(combining_character));
+    std::unique_ptr<KeyEvent> event(DeadKeyPress(combining_character));
     EXPECT_TRUE(character_composer_.FilterKeyPress(*event));
     EXPECT_TRUE(character_composer_.composed_character().empty());
   }
 
   // Expects key is filtered and the given character is composed.
   void ExpectDeadKeyComposed(base::char16 combining_character,
                              const base::string16& expected_character) {
-    scoped_ptr<KeyEvent> event(DeadKeyPress(combining_character));
+    std::unique_ptr<KeyEvent> event(DeadKeyPress(combining_character));
     EXPECT_TRUE(character_composer_.FilterKeyPress(*event));
     EXPECT_EQ(expected_character, character_composer_.composed_character());
   }
 
   // Returns a |KeyEvent| for a character key press.
   KeyEvent* UnicodeKeyPress(KeyboardCode vkey,
                             DomCode code,
                             int flags,
                             base::char16 character) const {
     KeyEvent* event = new KeyEvent(ET_KEY_PRESSED, vkey, code, flags,
                                    DomKey::FromCharacter(character),
                                    EventTimeForNow());
     return event;
   }
 
   // Expects key is not filtered and no character is composed.
   void ExpectUnicodeKeyNotFiltered(KeyboardCode vkey,
                                    DomCode code,
                                    int flags,
                                    base::char16 character) {
-    scoped_ptr<KeyEvent> event(UnicodeKeyPress(vkey, code, flags, character));
+    std::unique_ptr<KeyEvent> event(
+        UnicodeKeyPress(vkey, code, flags, character));
     EXPECT_FALSE(character_composer_.FilterKeyPress(*event));
     EXPECT_TRUE(character_composer_.composed_character().empty());
   }
 
   // Expects key is filtered and no character is composed.
   void ExpectUnicodeKeyFiltered(KeyboardCode vkey,
                                 DomCode code,
                                 int flags,
                                 base::char16 character) {
-    scoped_ptr<KeyEvent> event(UnicodeKeyPress(vkey, code, flags, character));
+    std::unique_ptr<KeyEvent> event(
+        UnicodeKeyPress(vkey, code, flags, character));
     EXPECT_TRUE(character_composer_.FilterKeyPress(*event));
     EXPECT_TRUE(character_composer_.composed_character().empty());
   }
 
   // Expects key is filtered and the given character is composed.
   void ExpectUnicodeKeyComposed(KeyboardCode vkey,
                                 DomCode code,
                                 int flags,
                                 base::char16 character,
                                 const base::string16& expected_character) {
-    scoped_ptr<KeyEvent> event(UnicodeKeyPress(vkey, code, flags, character));
+    std::unique_ptr<KeyEvent> event(
+        UnicodeKeyPress(vkey, code, flags, character));
     EXPECT_TRUE(character_composer_.FilterKeyPress(*event));
     EXPECT_EQ(expected_character, character_composer_.composed_character());
   }
 
   CharacterComposer character_composer_;
 };
 
 TEST_F(CharacterComposerTest, InitialState) {
   EXPECT_TRUE(character_composer_.composed_character().empty());
 }
@@ skipping 397 matching lines @@
   ExpectUnicodeKeyFiltered(VKEY_3, DomCode::DIGIT3, EF_NONE, '3');
   ExpectUnicodeKeyFiltered(VKEY_0, DomCode::DIGIT0, EF_NONE, '0');
   ExpectDeadKeyFiltered(kCombiningAcute);
   ExpectUnicodeKeyFiltered(VKEY_4, DomCode::DIGIT4, EF_NONE, '4');
   ExpectUnicodeKeyFiltered(VKEY_2, DomCode::DIGIT2, EF_NONE, '2');
   ExpectUnicodeKeyComposed(VKEY_SPACE, DomCode::SPACE, EF_NONE, ' ',
                            base::string16(1, 0x3042));
 }
 
 }  // namespace ui