Pepper: 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>
 
 #include "native_client/src/include/portability_io.h"
 #include "native_client/src/shared/platform/nacl_check.h"
 #include "native_client/src/shared/platform/nacl_time.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/cpp/url_request_info.h"
 #include "ppapi/cpp/url_response_info.h"
 #include "ppapi/native_client/src/trusted/plugin/callback_source.h"
 #include "ppapi/native_client/src/trusted/plugin/plugin.h"
 #include "ppapi/native_client/src/trusted/plugin/utility.h"
 
 namespace plugin {
 
-void FileDownloader::Initialize(Plugin* instance) {
-  PLUGIN_PRINTF(("FileDownloader::FileDownloader (this=%p)\n",
-                 static_cast<void*>(this)));
-  CHECK(instance != NULL);
-  CHECK(instance_ == NULL);  // Can only initialize once.
-  instance_ = instance;
+FileDownloader::FileDownloader(Plugin* instance)
+      : instance_(instance),

[dmichael (off chromium), 2014/05/28 20:20:19]

nit: indentation looks off

+        file_open_notify_callback_(pp::BlockUntilComplete()),
+        stream_finish_callback_(pp::BlockUntilComplete()),
+        mode_(DOWNLOAD_NONE),
+        data_stream_callback_source_(NULL) {
   callback_factory_.Initialize(this);
   temp_buffer_.resize(kTempBufferSize);
 }
 
 bool FileDownloader::OpenStream(
     const nacl::string& url,
     const pp::CompletionCallback& callback,
     StreamCallbackSource* stream_callback_source) {
   data_stream_callback_source_ = stream_callback_source;
   PLUGIN_PRINTF(("FileDownloader::Open (url=%s)\n", url.c_str()));
   if (callback.pp_completion_callback().func == NULL || instance_ == NULL)
     return false;
 
   status_code_ = -1;
-  url_ = url;
   file_open_notify_callback_ = callback;
   mode_ = DOWNLOAD_TO_BUFFER_AND_STREAM;
   pp::URLRequestInfo url_request(instance_);
 
   // Allow CORS.
   // 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_);
 
   // 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_request.SetRecordDownloadProgress(true);
 
   // Prepare the url request.
-  url_request.SetURL(url_);
+  url_request.SetURL(url);
 
   // 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));
@@ skipping 33 matching lines @@
   }
 
   if (!InitialResponseIsValid()) {
     file_open_notify_callback_.RunAndClear(PP_ERROR_FAILED);
     return;
   }
 
   file_open_notify_callback_.RunAndClear(PP_OK);
 }
 
-void FileDownloader::FinishStreaming(
+void FileDownloader::BeginStreaming(
     const pp::CompletionCallback& callback) {
   stream_finish_callback_ = callback;
 
   // Finish streaming the body providing an optional callback.
   pp::CompletionCallback onread_callback =
       callback_factory_.NewOptionalCallback(
           &FileDownloader::URLReadBodyNotify);
   int32_t temp_size = static_cast<int32_t>(temp_buffer_.size());
   int32_t pp_error = url_loader_.ReadResponseBody(&temp_buffer_[0],
                                                   temp_size,
@@ skipping 40 matching lines @@
   pp::Var headers = url_response_.GetHeaders();
   if (!headers.is_string()) {
     PLUGIN_PRINTF((
         "FileDownloader::GetResponseHeaders (headers are not a string)\n"));
     return nacl::string();
   }
   return headers.AsString();
 }
 
 }  // namespace plugin