Remove ScopedVector from content/renderer/.

content/renderer/pepper/pepper_url_loader_host.cc

 // Copyright (c) 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 "content/renderer/pepper/pepper_url_loader_host.h"
 
 #include <stddef.h>
 
+#include "base/memory/ptr_util.h"
 #include "content/renderer/pepper/pepper_plugin_instance_impl.h"
 #include "content/renderer/pepper/renderer_ppapi_host_impl.h"
 #include "content/renderer/pepper/url_request_info_util.h"
 #include "content/renderer/pepper/url_response_info_util.h"
 #include "net/base/net_errors.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/host/dispatch_host_message.h"
 #include "ppapi/host/host_message_context.h"
 #include "ppapi/host/ppapi_host.h"
 #include "ppapi/proxy/ppapi_messages.h"
@@ skipping 136 matching lines @@
 void PepperURLLoaderHost::didDownloadData(int data_length) {
   bytes_received_ += data_length;
   UpdateProgress();
 }
 
 void PepperURLLoaderHost::didReceiveData(const char* data, int data_length) {
   // Note that |loader| will be NULL for document loads.
   bytes_received_ += data_length;
   UpdateProgress();
 
-  PpapiPluginMsg_URLLoader_SendData* message =
-      new PpapiPluginMsg_URLLoader_SendData;
+  auto message = base::MakeUnique<PpapiPluginMsg_URLLoader_SendData>();
   message->WriteData(data, data_length);
-  SendUpdateToPlugin(message);
+  SendUpdateToPlugin(std::move(message));
 }
 
 void PepperURLLoaderHost::didFinishLoading(double finish_time) {
   // Note that |loader| will be NULL for document loads.
-  SendUpdateToPlugin(new PpapiPluginMsg_URLLoader_FinishedLoading(PP_OK));
+  SendUpdateToPlugin(
+      base::MakeUnique<PpapiPluginMsg_URLLoader_FinishedLoading>(PP_OK));
 }
 
 void PepperURLLoaderHost::didFail(const WebURLError& error) {
   // Note that |loader| will be NULL for document loads.
   int32_t pp_error = PP_ERROR_FAILED;
   if (error.domain.equals(WebString::fromUTF8(net::kErrorDomain))) {
     // TODO(bbudge): Extend pp_errors.h to cover interesting network errors
     // from the net error domain.
     switch (error.reason) {
       case net::ERR_ACCESS_DENIED:
       case net::ERR_NETWORK_ACCESS_DENIED:
         pp_error = PP_ERROR_NOACCESS;
         break;
     }
   } else {
     // It's a WebKit error.
     pp_error = PP_ERROR_NOACCESS;
   }
-  SendUpdateToPlugin(new PpapiPluginMsg_URLLoader_FinishedLoading(pp_error));
+  SendUpdateToPlugin(
+      base::MakeUnique<PpapiPluginMsg_URLLoader_FinishedLoading>(pp_error));
 }
 
 void PepperURLLoaderHost::DidConnectPendingHostToResource() {
-  for (size_t i = 0; i < pending_replies_.size(); i++)
-    host()->SendUnsolicitedReply(pp_resource(), *pending_replies_[i]);
+  for (const auto& reply : pending_replies_)
+    host()->SendUnsolicitedReply(pp_resource(), *reply);
   pending_replies_.clear();
 }
 
 int32_t PepperURLLoaderHost::OnHostMsgOpen(
     ppapi::host::HostMessageContext* context,
     const ppapi::URLRequestInfoData& request_data) {
   // An "Open" isn't a resource Call so has no reply, but failure to open
   // implies a load failure. To make it harder to forget to send the load
   // failed reply from the open handler, we instead catch errors and convert
   // them to load failed messages.
   int32_t ret = InternalOnHostMsgOpen(context, request_data);
   DCHECK(ret != PP_OK_COMPLETIONPENDING);
 
   if (ret != PP_OK)
-    SendUpdateToPlugin(new PpapiPluginMsg_URLLoader_FinishedLoading(ret));
+    SendUpdateToPlugin(
+        base::MakeUnique<PpapiPluginMsg_URLLoader_FinishedLoading>(ret));
   return PP_OK;
 }
 
 // Since this is wrapped by OnHostMsgOpen, we can return errors here and they
 // will be translated into a FinishedLoading call automatically.
 int32_t PepperURLLoaderHost::InternalOnHostMsgOpen(
     ppapi::host::HostMessageContext* context,
     const ppapi::URLRequestInfoData& request_data) {
   // Main document loads are already open, so don't allow people to open them
   // again.
@@ skipping 87 matching lines @@
 
 int32_t PepperURLLoaderHost::OnHostMsgGrantUniversalAccess(
     ppapi::host::HostMessageContext* context) {
   // Only plugins with private permission can bypass same origin.
   if (!host()->permissions().HasPermission(ppapi::PERMISSION_PRIVATE))
     return PP_ERROR_FAILED;
   has_universal_access_ = true;
   return PP_OK;
 }
 
-void PepperURLLoaderHost::SendUpdateToPlugin(IPC::Message* message) {
+void PepperURLLoaderHost::SendUpdateToPlugin(
+    std::unique_ptr<IPC::Message> message) {
   // We must send messages to the plugin in the order that the responses are
   // received from webkit, even when the host isn't ready to send messages or
   // when the host performs an asynchronous operation.
   //
   // Only {FinishedLoading, ReceivedResponse, SendData} have ordering
   // contraints; all other messages are immediately added to pending_replies_.
   //
   // Accepted orderings for {FinishedLoading, ReceivedResponse, SendData} are:
   //   - {ReceivedResponse, SendData (zero or more times), FinishedLoading}
   //   - {FinishedLoading (when status != PP_OK)}
   if (message->type() == PpapiPluginMsg_URLLoader_SendData::ID ||
       message->type() == PpapiPluginMsg_URLLoader_FinishedLoading::ID) {
     // Messages that must be sent after ReceivedResponse.
     if (pending_response_) {
-      out_of_order_replies_.push_back(message);
+      out_of_order_replies_.push_back(std::move(message));
     } else {
-      SendOrderedUpdateToPlugin(message);
+      SendOrderedUpdateToPlugin(std::move(message));
     }
   } else if (message->type() == PpapiPluginMsg_URLLoader_ReceivedResponse::ID) {
     // Allow SendData and FinishedLoading into the ordered queue.
     DCHECK(pending_response_);
-    SendOrderedUpdateToPlugin(message);
-    for (size_t i = 0; i < out_of_order_replies_.size(); i++)
-      SendOrderedUpdateToPlugin(out_of_order_replies_[i]);
-    // SendOrderedUpdateToPlugin destroys the messages for us.
-    out_of_order_replies_.weak_clear();
+    SendOrderedUpdateToPlugin(std::move(message));
+    for (auto& reply : out_of_order_replies_)
+      SendOrderedUpdateToPlugin(std::move(reply));
+    out_of_order_replies_.clear();
     pending_response_ = false;
   } else {
     // Messages without ordering constraints.
-    SendOrderedUpdateToPlugin(message);
+    SendOrderedUpdateToPlugin(std::move(message));
   }
 }
 
-void PepperURLLoaderHost::SendOrderedUpdateToPlugin(IPC::Message* message) {
+void PepperURLLoaderHost::SendOrderedUpdateToPlugin(
+    std::unique_ptr<IPC::Message> message) {
   if (pp_resource() == 0) {
-    pending_replies_.push_back(message);
+    pending_replies_.push_back(std::move(message));
   } else {
     host()->SendUnsolicitedReply(pp_resource(), *message);
-    delete message;
   }
 }
 
 void PepperURLLoaderHost::Close() {
   if (loader_.get()) {
     loader_->cancel();
   } else if (main_document_loader_) {
     // TODO(raymes): Calling WebLocalFrame::stopLoading here is incorrect as it
     // cancels all URL loaders associated with the frame. If a client has opened
     // other URLLoaders and then closes the main one, the others should still
@@ skipping 39 matching lines @@
         renderer_ppapi_host_,
         pp_instance(),
         response,
         base::Bind(&PepperURLLoaderHost::DidDataFromWebURLResponse,
                    weak_factory_.GetWeakPtr()));
   }
 }
 
 void PepperURLLoaderHost::DidDataFromWebURLResponse(
     const ppapi::URLResponseInfoData& data) {
-  SendUpdateToPlugin(new PpapiPluginMsg_URLLoader_ReceivedResponse(data));
+  SendUpdateToPlugin(
+      base::MakeUnique<PpapiPluginMsg_URLLoader_ReceivedResponse>(data));
 }
 
 void PepperURLLoaderHost::UpdateProgress() {
   bool record_download = request_data_.record_download_progress;
   bool record_upload = request_data_.record_upload_progress;
   if (record_download || record_upload) {
     // Here we go through some effort to only send the exact information that
     // the requestor wanted in the request flags. It would be just as
     // efficient to send all of it, but we don't want people to rely on
     // getting download progress when they happen to set the upload progress
     // flag.
     ppapi::proxy::ResourceMessageReplyParams params;
-    SendUpdateToPlugin(new PpapiPluginMsg_URLLoader_UpdateProgress(
-        record_upload ? bytes_sent_ : -1,
-        record_upload ? total_bytes_to_be_sent_ : -1,
-        record_download ? bytes_received_ : -1,
-        record_download ? total_bytes_to_be_received_ : -1));
+    SendUpdateToPlugin(
+        base::MakeUnique<PpapiPluginMsg_URLLoader_UpdateProgress>(
+            record_upload ? bytes_sent_ : -1,
+            record_upload ? total_bytes_to_be_sent_ : -1,
+            record_download ? bytes_received_ : -1,
+            record_download ? total_bytes_to_be_received_ : -1));
   }
 }
 
 }  // namespace content