Don't try to call setDefersLoading when the loader is null. This does a bit of cleanup so the che...

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 78 matching lines @@
   return this;
 }
 
 void PPB_URLLoader_Impl::InstanceWasDeleted() {
   Resource::InstanceWasDeleted();
   loader_.reset();
 }
 
 int32_t PPB_URLLoader_Impl::Open(PP_Resource request_id,
                                  PP_CompletionCallback callback) {
+  // Main document loads are already open, so don't allow people to open them
+  // again.
+  if (main_document_loader_)
+    return PP_ERROR_INPROGRESS;
+
   EnterResourceNoLock<PPB_URLRequestInfo_API> enter_request(request_id, true);
   if (enter_request.failed())
     return PP_ERROR_BADARGUMENT;
   PPB_URLRequestInfo_Impl* request = static_cast<PPB_URLRequestInfo_Impl*>(
       enter_request.object());
 
   int32_t rv = ValidateCallback(callback);
   if (rv != PP_OK)
     return rv;
 
@@ skipping 40 matching lines @@
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PPB_URLLoader_Impl::FollowRedirect(PP_CompletionCallback callback) {
   int32_t rv = ValidateCallback(callback);
   if (rv != PP_OK)
     return rv;
 
   WebURL redirect_url = GURL(response_info_->redirect_url());
 
-  loader_->setDefersLoading(false);  // Allow the redirect to continue.
+  SetDefersLoading(false);  // Allow the redirect to continue.
   RegisterCallback(callback);
   return PP_OK_COMPLETIONPENDING;
 }
 
 PP_Bool PPB_URLLoader_Impl::GetUploadProgress(int64_t* bytes_sent,
                                               int64_t* total_bytes_to_be_sent) {
   if (!RecordUploadProgress()) {
     *bytes_sent = 0;
     *total_bytes_to_be_sent = 0;
     return PP_FALSE;
@@ skipping 56 matching lines @@
   if (rv != PP_OK)
     return rv;
   if (!response_info_ || !response_info_->body())
     return PP_ERROR_FAILED;
 
   // We may have already reached EOF.
   if (done_status_ != PP_OK_COMPLETIONPENDING)
     return done_status_;
 
   is_streaming_to_file_ = true;
-  if (is_asynchronous_load_suspended_) {
-    loader_->setDefersLoading(false);
-    is_asynchronous_load_suspended_ = false;
-  }
+  if (is_asynchronous_load_suspended_)
+    SetDefersLoading(false);
 
   // Wait for didFinishLoading / didFail.
   RegisterCallback(callback);
   return PP_OK_COMPLETIONPENDING;
 }
 
 void PPB_URLLoader_Impl::Close() {
   if (loader_.get())
     loader_->cancel();
   else if (main_document_loader_)
@@ skipping 10 matching lines @@
     PP_URLLoaderTrusted_StatusCallback cb) {
   status_callback_ = cb;
 }
 
 void PPB_URLLoader_Impl::willSendRequest(
     WebURLLoader* loader,
     WebURLRequest& new_request,
     const WebURLResponse& redirect_response) {
   if (!request_data_.follow_redirects) {
     SaveResponse(redirect_response);
-    loader_->setDefersLoading(true);
+    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) {
   // TODO(darin): Bounds check input?
   bytes_sent_ = static_cast<int64_t>(bytes_sent);
@@ skipping 15 matching lines @@
 void PPB_URLLoader_Impl::didDownloadData(WebURLLoader* loader,
                                          int data_length) {
   bytes_received_ += data_length;
   UpdateStatus();
 }
 
 void PPB_URLLoader_Impl::didReceiveData(WebURLLoader* loader,
                                         const char* data,
                                         int data_length,
                                         int encoded_data_length) {
+  // Note that |loader| will be NULL for document loads.
   bytes_received_ += data_length;
   UpdateStatus();
 
   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_data_.prefetch_buffer_lower_threshold <
          request_data_.prefetch_buffer_upper_threshold);
   if (!is_streaming_to_file_ &&
       !is_asynchronous_load_suspended_ &&
       (buffer_.size() >= static_cast<size_t>(
           request_data_.prefetch_buffer_upper_threshold))) {
     DVLOG(1) << "Suspending async load - buffer size: " << buffer_.size();
-    loader->setDefersLoading(true);
-    is_asynchronous_load_suspended_ = true;
+    SetDefersLoading(true);
   }
 }
 
 void PPB_URLLoader_Impl::didFinishLoading(WebURLLoader* loader,
                                           double finish_time) {
   FinishLoading(PP_OK);
 }
 
 void PPB_URLLoader_Impl::didFail(WebURLLoader* loader,
                                  const WebURLError& error) {
   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;
   }
 
   FinishLoading(pp_error);
 }
 
+void PPB_URLLoader_Impl::SetDefersLoading(bool defers_loading) {
+  if (loader_.get()) {
+    loader_->setDefersLoading(defers_loading);
+    is_asynchronous_load_suspended_ = defers_loading;
+  }
+
+  // TODO(brettw) bug 96770: We need a way to set the defers loading flag on
+  // main document loads (when the loader_ is null).
+}
+
 void PPB_URLLoader_Impl::FinishLoading(int32_t done_status) {
   done_status_ = done_status;
   // If the client hasn't called any function that takes a callback since
   // the initial call to Open, or called ReadResponseBody and got a
   // synchronous return, then the callback will be NULL.
   if (pending_callback_.get() && !pending_callback_->completed())
     RunCallback(done_status_);
 }
 
 int32_t PPB_URLLoader_Impl::ValidateCallback(PP_CompletionCallback callback) {
@@ skipping 37 matching lines @@
 
   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.
   if (is_asynchronous_load_suspended_ &&
       buffer_.size() <= static_cast<size_t>(
           request_data_.prefetch_buffer_lower_threshold)) {
     DVLOG(1) << "Resuming async load - buffer size: " << buffer_.size();
-    loader_->setDefersLoading(false);
-    is_asynchronous_load_suspended_ = false;
+    SetDefersLoading(false);
   }
 
   // Reset for next time.
   user_buffer_ = NULL;
   user_buffer_size_ = 0;
   return bytes_to_copy;
 }
 
 void PPB_URLLoader_Impl::SaveResponse(const WebURLResponse& response) {
   scoped_refptr<PPB_URLResponseInfo_Impl> response_info(
@@ skipping 22 matching lines @@
 bool PPB_URLLoader_Impl::RecordDownloadProgress() const {
   return request_data_.record_download_progress;
 }
 
 bool PPB_URLLoader_Impl::RecordUploadProgress() const {
   return request_data_.record_upload_progress;
 }
 
 }  // namespace ppapi
 }  // namespace webkit