Pepper: More FileDownloader cleanup.

ppapi/native_client/src/trusted/plugin/file_downloader.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 "ppapi/native_client/src/trusted/plugin/file_downloader.h"
 
 #include <stdio.h>
 #include <string.h>
 #include <string>
 
@@ skipping 90 matching lines @@
   url_loader_trusted_interface_ = static_cast<const PPB_URLLoaderTrusted*>(
       pp::Module::Get()->GetBrowserInterface(PPB_URLLOADERTRUSTED_INTERFACE));
   temp_buffer_.resize(kTempBufferSize);
   file_info_.FreeResources();
 }
 
 bool FileDownloader::OpenStream(
     const nacl::string& url,
     const pp::CompletionCallback& callback,
     StreamCallbackSource* stream_callback_source) {
-  open_and_stream_ = false;
   data_stream_callback_source_ = stream_callback_source;
   return Open(url, DOWNLOAD_STREAM, callback, true, NULL);
 }
 
 bool FileDownloader::Open(
     const nacl::string& url,
     DownloadMode mode,
     const pp::CompletionCallback& callback,
     bool record_progress,
     PP_URLLoaderTrusted_StatusCallback progress_callback) {
@@ skipping 17 matching lines @@
   // Note that "SetAllowCrossOriginRequests" (currently) has the side effect of
   // preventing credentials from being sent on same-origin requests.  We
   // therefore avoid setting this flag unless we know for sure it is a
   // cross-origin request, resulting in behavior similar to XMLHttpRequest.
   if (!instance_->DocumentCanRequest(url))
     url_request.SetAllowCrossOriginRequests(true);
 
   if (!extra_request_headers_.empty())
     url_request.SetHeaders(extra_request_headers_);
 
-  do {
-    // Reset the url loader and file reader.
-    // Note that we have the only reference to the underlying objects, so
-    // this will implicitly close any pending IO and destroy them.
-    url_loader_ = pp::URLLoader(instance_);
-    url_scheme_ = instance_->GetUrlScheme(url);
-    bool grant_universal_access = false;
-    if (url_scheme_ == SCHEME_DATA) {
-      // TODO(elijahtaylor) Remove this when data URIs can be read without
-      // universal access.
-      // https://bugs.webkit.org/show_bug.cgi?id=17352
-      if (streaming_to_buffer()) {
-        grant_universal_access = true;
-      } else {
-        // Open is to invoke a callback on success or failure. Schedule
-        // it asynchronously to follow PPAPI's convention and avoid reentrancy.
-        pp::Core* core = pp::Module::Get()->core();
-        core->CallOnMainThread(0, callback, PP_ERROR_NOACCESS);
-        PLUGIN_PRINTF(("FileDownloader::Open (pp_error=PP_ERROR_NOACCESS)\n"));
-        return true;
-      }
+  // Reset the url loader and file reader.
+  // Note that we have the only reference to the underlying objects, so
+  // this will implicitly close any pending IO and destroy them.
+  url_loader_ = pp::URLLoader(instance_);
+  url_scheme_ = instance_->GetUrlScheme(url);
+  bool grant_universal_access = false;
+  if (url_scheme_ == SCHEME_DATA) {
+    // TODO(elijahtaylor) Remove this when data URIs can be read without
+    // universal access.
+    // https://bugs.webkit.org/show_bug.cgi?id=17352
+    if (streaming_to_buffer()) {
+      grant_universal_access = true;
+    } else {
+      // Open is to invoke a callback on success or failure. Schedule
+      // it asynchronously to follow PPAPI's convention and avoid reentrancy.
+      pp::Core* core = pp::Module::Get()->core();
+      core->CallOnMainThread(0, callback, PP_ERROR_NOACCESS);
+      PLUGIN_PRINTF(("FileDownloader::Open (pp_error=PP_ERROR_NOACCESS)\n"));
+      return true;
     }
+  }
 
-    url_request.SetRecordDownloadProgress(record_progress);
+  url_request.SetRecordDownloadProgress(record_progress);
 
-    if (url_loader_trusted_interface_ != NULL) {
-      if (grant_universal_access) {
-        // TODO(sehr,jvoung): See if we can remove this -- currently
-        // only used for data URIs.
-        url_loader_trusted_interface_->GrantUniversalAccess(
-            url_loader_.pp_resource());
-      }
-      if (progress_callback != NULL) {
-        url_loader_trusted_interface_->RegisterStatusCallback(
-            url_loader_.pp_resource(), progress_callback);
-      }
+  if (url_loader_trusted_interface_ != NULL) {
+    if (grant_universal_access) {
+      // TODO(sehr,jvoung): See if we can remove this -- currently
+      // only used for data URIs.
+      url_loader_trusted_interface_->GrantUniversalAccess(
+          url_loader_.pp_resource());
     }
+    if (progress_callback != NULL) {
+      url_loader_trusted_interface_->RegisterStatusCallback(
+          url_loader_.pp_resource(), progress_callback);
+    }
+  }
 
-    // Prepare the url request.
-    url_request.SetURL(url_);
+  // Prepare the url request.
+  url_request.SetURL(url_);
 
-    if (streaming_to_file()) {
-      file_reader_ = pp::FileIO(instance_);
-      url_request.SetStreamToFile(true);
-    }
-  } while (0);
+  if (streaming_to_file()) {
+    file_reader_ = pp::FileIO(instance_);
+    url_request.SetStreamToFile(true);
+  }
 
   // Request asynchronous download of the url providing an on-load callback.
   // As long as this step is guaranteed to be asynchronous, we can call
   // synchronously all other internal callbacks that eventually result in the
   // invocation of the user callback. The user code will not be reentered.
   pp::CompletionCallback onload_callback =
       callback_factory_.NewCallback(&FileDownloader::URLLoadStartNotify);
   int32_t pp_error = url_loader_.Open(url_request, onload_callback);
   PLUGIN_PRINTF(("FileDownloader::Open (pp_error=%" NACL_PRId32 ")\n",
                  pp_error));
   CHECK(pp_error == PP_OK_COMPLETIONPENDING);
   return true;
 }
 
 void FileDownloader::OpenFast(const nacl::string& url,
                               PP_FileHandle file_handle,
                               uint64_t file_token_lo, uint64_t file_token_hi) {
   PLUGIN_PRINTF(("FileDownloader::OpenFast (url=%s)\n", url.c_str()));
 
   file_info_.FreeResources();
   CHECK(instance_ != NULL);
   open_time_ = NaClGetTimeOfDayMicroseconds();
   status_code_ = NACL_HTTP_STATUS_OK;
   url_ = url;
   mode_ = DOWNLOAD_NONE;
-  if (not_streaming() && file_handle != PP_kInvalidFileHandle) {
+  if (file_handle != PP_kInvalidFileHandle) {
     NaClFileInfo tmp_info = NoFileInfo();
     tmp_info.desc = ConvertFileDescriptor(file_handle);
     tmp_info.file_token.lo = file_token_lo;
     tmp_info.file_token.hi = file_token_hi;
     file_info_.TakeOwnership(&tmp_info);
   }
 }
 
 NaClFileInfo FileDownloader::GetFileInfo() {
   NaClFileInfo info_to_return = NoFileInfo();
@@ skipping 65 matching lines @@
   if (pp_error != PP_OK) {
     file_open_notify_callback_.RunAndClear(pp_error);
     return;
   }
 
   if (!InitialResponseIsValid()) {
     file_open_notify_callback_.RunAndClear(PP_ERROR_FAILED);
     return;
   }
 
-  if (open_and_stream_) {
+  if (!streaming_to_user()) {
     FinishStreaming(file_open_notify_callback_);
     return;
   }
 
   file_open_notify_callback_.RunAndClear(PP_OK);
 }
 
 void FileDownloader::FinishStreaming(
     const pp::CompletionCallback& callback) {
   stream_finish_callback_ = callback;
@@ skipping 152 matching lines @@
 }
 
 bool FileDownloader::streaming_to_buffer() const {
   return mode_ == DOWNLOAD_TO_BUFFER;
 }
 
 bool FileDownloader::streaming_to_user() const {
   return mode_ == DOWNLOAD_STREAM;
 }
 
-bool FileDownloader::not_streaming() const {
-  return mode_ == DOWNLOAD_NONE;
-}
-
 void FileDownloader::GotFileHandleNotify(int32_t pp_error,
                                          PP_FileHandle handle) {
   PLUGIN_PRINTF((
       "FileDownloader::GotFileHandleNotify (pp_error=%" NACL_PRId32 ")\n",
       pp_error));
   if (pp_error == PP_OK) {
     NaClFileInfo tmp_info = NoFileInfo();
     tmp_info.desc = ConvertFileDescriptor(handle);
     file_info_.TakeOwnership(&tmp_info);
   }
 
   stream_finish_callback_.RunAndClear(pp_error);
 }
 
 }  // namespace plugin