Use scoped_ptr instead of linked_ptr from /content/renderer

content/renderer/pepper/event_conversion.cc

 // Copyright (c) 2012 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/pepper/event_conversion.h"
 
 #include "base/basictypes.h"
 #include "base/i18n/char_iterator.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 615 matching lines @@
     case PP_INPUTEVENT_TYPE_TOUCHCANCEL:
       web_input_event.reset(BuildTouchEvent(event));
       break;
   }
 
   return web_input_event.release();
 }
 
 // Generate a coherent sequence of input events to simulate a user event.
 // From src/components/test_runner/event_sender.cc.
-std::vector<linked_ptr<WebInputEvent> > CreateSimulatedWebInputEvents(
+std::vector<scoped_ptr<WebInputEvent>> CreateSimulatedWebInputEvents(
     const ppapi::InputEventData& event,
     int plugin_x,
     int plugin_y) {
-  std::vector<linked_ptr<WebInputEvent> > events;
-  linked_ptr<WebInputEvent> original_event(CreateWebInputEvent(event));
+  std::vector<scoped_ptr<WebInputEvent>> events;
+  scoped_ptr<WebInputEvent> original_event(CreateWebInputEvent(event));
 
   switch (event.event_type) {
     case PP_INPUTEVENT_TYPE_MOUSEDOWN:
     case PP_INPUTEVENT_TYPE_MOUSEUP:
     case PP_INPUTEVENT_TYPE_MOUSEMOVE:
     case PP_INPUTEVENT_TYPE_MOUSEENTER:
     case PP_INPUTEVENT_TYPE_MOUSELEAVE:
     case PP_INPUTEVENT_TYPE_TOUCHSTART:
     case PP_INPUTEVENT_TYPE_TOUCHMOVE:
     case PP_INPUTEVENT_TYPE_TOUCHEND:
     case PP_INPUTEVENT_TYPE_TOUCHCANCEL:
-      events.push_back(original_event);
+      events.push_back(std::move(original_event));
       break;
 
     case PP_INPUTEVENT_TYPE_WHEEL: {
       WebMouseWheelEvent* web_mouse_wheel_event =
           static_cast<WebMouseWheelEvent*>(original_event.get());
       web_mouse_wheel_event->x = plugin_x;
       web_mouse_wheel_event->y = plugin_y;
-      events.push_back(original_event);
+      events.push_back(std::move(original_event));
       break;
     }
 
     case PP_INPUTEVENT_TYPE_RAWKEYDOWN:
     case PP_INPUTEVENT_TYPE_KEYDOWN:
     case PP_INPUTEVENT_TYPE_KEYUP: {
 // Windows key down events should always be "raw" to avoid an ASSERT.
 #if defined(OS_WIN)
       WebKeyboardEvent* web_keyboard_event =
           static_cast<WebKeyboardEvent*>(original_event.get());
       if (web_keyboard_event->type == WebInputEvent::KeyDown)
         web_keyboard_event->type = WebInputEvent::RawKeyDown;
 #endif
-      events.push_back(original_event);
+      events.push_back(std::move(original_event));
       break;
     }
 
     case PP_INPUTEVENT_TYPE_CHAR: {
       WebKeyboardEvent* web_char_event =
           static_cast<WebKeyboardEvent*>(original_event.get());
 
       WebUChar code = 0, text = 0;
       bool needs_shift_modifier = false, generate_char = false;
       GetKeyCode(event.character_text,
@@ skipping 15 matching lines @@
       // If a char event is needed, set the text fields.
       if (generate_char) {
         key_down_event->text[0] = text;
         key_down_event->unmodifiedText[0] = text;
       }
       // Convert the key code to a string identifier.
       key_down_event->setKeyIdentifierFromWindowsKeyCode();
 
       *key_up_event = *web_char_event = *key_down_event;
 
-      events.push_back(linked_ptr<WebInputEvent>(key_down_event.release()));
+      events.push_back(std::move(key_down_event));
 
       if (generate_char) {
         web_char_event->type = WebInputEvent::Char;
         web_char_event->keyIdentifier[0] = '\0';
-        events.push_back(original_event);
+        events.push_back(std::move(original_event));
       }
 
       key_up_event->type = WebInputEvent::KeyUp;
-      events.push_back(linked_ptr<WebInputEvent>(key_up_event.release()));
+      events.push_back(std::move(key_up_event));
       break;
     }
 
     default:
       break;
   }
   return events;
 }
 
 PP_InputEvent_Class ClassifyInputEvent(WebInputEvent::Type type) {
@@ skipping 18 matching lines @@
     case WebInputEvent::TouchStart:
       return PP_INPUTEVENT_CLASS_TOUCH;
     case WebInputEvent::Undefined:
     default:
       CHECK(WebInputEvent::isGestureEventType(type));
       return PP_InputEvent_Class(0);
   }
 }
 
 }  // namespace content