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

extensions/renderer/wake_event_page.cc

 // Copyright 2015 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 "extensions/renderer/wake_event_page.h"
 
+#include <memory>
 #include <utility>
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "content/public/child/worker_thread.h"
 #include "content/public/renderer/render_thread.h"
 #include "extensions/common/extension_messages.h"
 #include "extensions/renderer/object_backed_native_handler.h"
 #include "extensions/renderer/script_context.h"
 #include "extensions/renderer/v8_helpers.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_message_macros.h"
 
 namespace extensions {
@@ skipping 127 matching lines @@
 
 WakeEventPage::WakeEventPage() {}
 
 WakeEventPage::~WakeEventPage() {}
 
 void WakeEventPage::MakeRequest(const std::string& extension_id,
                                 const OnResponseCallback& on_response) {
   static base::AtomicSequenceNumber sequence_number;
   int request_id = sequence_number.GetNext();
   {
-    scoped_ptr<RequestData> request_data(
+    std::unique_ptr<RequestData> request_data(
         new RequestData(content::WorkerThread::GetCurrentId(), on_response));
     base::AutoLock lock(requests_lock_);
     requests_.set(request_id, std::move(request_data));
   }
   message_filter_->Send(
       new ExtensionHostMsg_WakeEventPage(request_id, extension_id));
 }
 
 bool WakeEventPage::OnControlMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(WakeEventPage, message)
     IPC_MESSAGE_HANDLER(ExtensionMsg_WakeEventPageResponse,
                         OnWakeEventPageResponse)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void WakeEventPage::OnWakeEventPageResponse(int request_id, bool success) {
-  scoped_ptr<RequestData> request_data;
+  std::unique_ptr<RequestData> request_data;
   {
     base::AutoLock lock(requests_lock_);
     request_data = requests_.take(request_id);
   }
   CHECK(request_data) << "No request with ID " << request_id;
   if (request_data->thread_id == 0) {
     // Thread ID of 0 means it wasn't called on a worker thread, so safe to
     // call immediately.
     request_data->on_response.Run(success);
   } else {
     content::WorkerThread::PostTask(
         request_data->thread_id,
         base::Bind(request_data->on_response, success));
   }
 }
 
 }  //  namespace extensions