Convert FileRefImpl and URLRequestInfo to shared_impl.

webkit/plugins/ppapi/ppb_url_loader_impl.cc

 // Copyright (c) 2011 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 "webkit/plugins/ppapi/ppb_url_loader_impl.h"
 
 #include "base/logging.h"
 #include "net/base/net_errors.h"
 #include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/pp_errors.h"
@@ skipping 97 matching lines @@
 
   if (request->RequiresUniversalAccess() && !has_universal_access_)
     return PP_ERROR_NOACCESS;
 
   if (loader_.get())
     return PP_ERROR_INPROGRESS;
 
   WebFrame* frame = GetFrameForResource(this);
   if (!frame)
     return PP_ERROR_FAILED;
-  WebURLRequest web_request(request->ToWebURLRequest(frame));
+  WebURLRequest web_request;
+  if (!request->ToWebURLRequest(frame, &web_request))
+    return PP_ERROR_FAILED;
+
+  // Save a copy of the request info so the plugin can continue to use and
+  // change it while we're doing the request without affecting us. We must do
+  // this after ToWebURLRequest since that fills out the file refs.
+  request_data_ = request->GetData();
 
   WebURLLoaderOptions options;
   if (has_universal_access_) {
     // Universal access allows cross-origin requests and sends credentials.
     options.crossOriginRequestPolicy =
         WebURLLoaderOptions::CrossOriginRequestPolicyAllow;
     options.allowCredentials = true;
-  } else if (request->allow_cross_origin_requests()) {
+  } else if (request_data_.allow_cross_origin_requests) {
     // Otherwise, allow cross-origin requests with access control.
     options.crossOriginRequestPolicy =
         WebURLLoaderOptions::CrossOriginRequestPolicyUseAccessControl;
-    options.allowCredentials = request->allow_credentials();
+    options.allowCredentials = request_data_.allow_credentials;
   }
 
   is_asynchronous_load_suspended_ = false;
   loader_.reset(frame->createAssociatedURLLoader(options));
   if (!loader_.get())
     return PP_ERROR_FAILED;
 
   loader_->loadAsynchronously(web_request, this);
 
-  request_info_ = scoped_refptr<PPB_URLRequestInfo_Impl>(request);
-
   // Notify completion when we receive a redirect or response headers.
   RegisterCallback(callback);
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PPB_URLLoader_Impl::FollowRedirect(PP_CompletionCallback callback) {
   int32_t rv = ValidateCallback(callback);
   if (rv != PP_OK)
     return rv;
 
@@ skipping 101 matching lines @@
 
 void PPB_URLLoader_Impl::SetStatusCallback(
     PP_URLLoaderTrusted_StatusCallback cb) {
   status_callback_ = cb;
 }
 
 void PPB_URLLoader_Impl::willSendRequest(
     WebURLLoader* loader,
     WebURLRequest& new_request,
     const WebURLResponse& redirect_response) {
-  if (!request_info_->follow_redirects()) {
+  if (!request_data_.follow_redirects) {
     SaveResponse(redirect_response);
     loader_->setDefersLoading(true);
     RunCallback(PP_OK);
   }
 }
 
 void PPB_URLLoader_Impl::didSendData(
     WebURLLoader* loader,
     unsigned long long bytes_sent,
     unsigned long long total_bytes_to_be_sent) {
@@ skipping 29 matching lines @@
   buffer_.insert(buffer_.end(), data, data + data_length);
   if (user_buffer_) {
     RunCallback(FillUserBuffer());
   } else {
     DCHECK(!pending_callback_.get() || pending_callback_->completed());
   }
 
   // To avoid letting the network stack download an entire stream all at once,
   // defer loading when we have enough buffer.
   // Check the buffer size after potentially moving some to the user buffer.
-  DCHECK(!request_info_ ||
-         (request_info_->prefetch_buffer_lower_threshold() <
-          request_info_->prefetch_buffer_upper_threshold()));
+  DCHECK(request_data_.prefetch_buffer_lower_threshold <
+         request_data_.prefetch_buffer_upper_threshold);
   if (!is_streaming_to_file_ &&
       !is_asynchronous_load_suspended_ &&
-      request_info_ &&
       (buffer_.size() >= static_cast<size_t>(
-          request_info_->prefetch_buffer_upper_threshold()))) {
+          request_data_.prefetch_buffer_upper_threshold))) {
     DVLOG(1) << "Suspending async load - buffer size: " << buffer_.size();
     loader->setDefersLoading(true);
     is_asynchronous_load_suspended_ = true;
   }
 }
 
 void PPB_URLLoader_Impl::didFinishLoading(WebURLLoader* loader,
                                           double finish_time) {
   FinishLoading(PP_OK);
 }
@@ skipping 64 matching lines @@
 
 size_t PPB_URLLoader_Impl::FillUserBuffer() {
   DCHECK(user_buffer_);
   DCHECK(user_buffer_size_);
 
   size_t bytes_to_copy = std::min(buffer_.size(), user_buffer_size_);
   std::copy(buffer_.begin(), buffer_.begin() + bytes_to_copy, user_buffer_);
   buffer_.erase(buffer_.begin(), buffer_.begin() + bytes_to_copy);
 
   // If the buffer is getting too empty, resume asynchronous loading.
-  DCHECK(!is_asynchronous_load_suspended_ || request_info_);
+  DCHECK(!is_asynchronous_load_suspended_);
   if (is_asynchronous_load_suspended_ &&
       buffer_.size() <= static_cast<size_t>(
-          request_info_->prefetch_buffer_lower_threshold())) {
+          request_data_.prefetch_buffer_lower_threshold)) {
     DVLOG(1) << "Resuming async load - buffer size: " << buffer_.size();
     loader_->setDefersLoading(false);
     is_asynchronous_load_suspended_ = false;
   }
 
   // Reset for next time.
   user_buffer_ = NULL;
   user_buffer_size_ = 0;
   return bytes_to_copy;
 }
@@ skipping 16 matching lines @@
     status_callback_(
         pp_instance(), pp_resource(),
         RecordUploadProgress() ? bytes_sent_ : -1,
         RecordUploadProgress() ?  total_bytes_to_be_sent_ : -1,
         RecordDownloadProgress() ? bytes_received_ : -1,
         RecordDownloadProgress() ? total_bytes_to_be_received_ : -1);
   }
 }
 
 bool PPB_URLLoader_Impl::RecordDownloadProgress() const {
-  return request_info_ && request_info_->record_download_progress();
+  return request_data_.record_download_progress;
 }
 
 bool PPB_URLLoader_Impl::RecordUploadProgress() const {
-  return request_info_ && request_info_->record_upload_progress();
+  return request_data_.record_upload_progress;
 }
 
 }  // namespace ppapi
 }  // namespace webkit