Stream to file implementation.

webkit/glue/plugins/pepper_url_loader.cc

 // Copyright (c) 2010 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/glue/plugins/pepper_url_loader.h"
 
 #include "base/logging.h"
 #include "third_party/ppapi/c/pp_completion_callback.h"
 #include "third_party/ppapi/c/pp_errors.h"
 #include "third_party/ppapi/c/ppb_url_loader.h"
@@ skipping 104 matching lines @@
                          char* buffer,
                          int32_t bytes_to_read,
                          PP_CompletionCallback callback) {
   scoped_refptr<URLLoader> loader(Resource::GetAs<URLLoader>(loader_id));
   if (!loader)
     return PP_ERROR_BADRESOURCE;
 
   return loader->ReadResponseBody(buffer, bytes_to_read, callback);
 }
 
+int32_t FinishStreamingToFile(PP_Resource loader_id,
+                              PP_CompletionCallback callback) {
+  scoped_refptr<URLLoader> loader(Resource::GetAs<URLLoader>(loader_id));
+  if (!loader)
+    return PP_ERROR_BADRESOURCE;
+
+  return loader->FinishStreamingToFile(callback);
+}
+
 void Close(PP_Resource loader_id) {
   scoped_refptr<URLLoader> loader(Resource::GetAs<URLLoader>(loader_id));
   if (!loader)
     return;
 
   loader->Close();
 }
 
 const PPB_URLLoader ppb_urlloader = {
   &Create,
   &IsURLLoader,
   &Open,
   &FollowRedirect,
   &GetUploadProgress,
   &GetDownloadProgress,
   &GetResponseInfo,
   &ReadResponseBody,
+  &FinishStreamingToFile,
   &Close
 };
 
 }  // namespace
 
 URLLoader::URLLoader(PluginInstance* instance)
     : Resource(instance->module()),
       instance_(instance),
       pending_callback_(),
       bytes_sent_(0),
       total_bytes_to_be_sent_(-1),
       bytes_received_(0),
       total_bytes_to_be_received_(-1),
       user_buffer_(NULL),
       user_buffer_size_(0),
-      done_(false) {
+      done_status_(PP_ERROR_WOULDBLOCK) {
 }
 
 URLLoader::~URLLoader() {
 }
 
 // static
 const PPB_URLLoader* URLLoader::GetInterface() {
   return &ppb_urlloader;
 }
 
@@ skipping 25 matching lines @@
   return PP_ERROR_WOULDBLOCK;
 }
 
 int32_t URLLoader::FollowRedirect(PP_CompletionCallback callback) {
   NOTIMPLEMENTED();  // TODO(darin): Implement me.
   return PP_ERROR_FAILED;
 }
 
 int32_t URLLoader::ReadResponseBody(char* buffer, int32_t bytes_to_read,
                                     PP_CompletionCallback callback) {
+  if (!response_info_ || response_info_->body())
+    return PP_ERROR_FAILED;
   if (bytes_to_read <= 0 || !buffer)
     return PP_ERROR_BADARGUMENT;
   if (pending_callback_.func)
     return PP_ERROR_INPROGRESS;
 
   // We only support non-blocking calls.
   if (!callback.func)
     return PP_ERROR_BADARGUMENT;
 
   user_buffer_ = buffer;
   user_buffer_size_ = bytes_to_read;
 
   if (!buffer_.empty())
     return FillUserBuffer();
 
-  if (done_) {
+  // We may have already reached EOF.
+  if (done_status_ != PP_ERROR_WOULDBLOCK) {
     user_buffer_ = NULL;
     user_buffer_size_ = 0;
-    return 0;
+    return done_status_;
   }
 
   pending_callback_ = callback;
   return PP_ERROR_WOULDBLOCK;
 }
 
+int32_t URLLoader::FinishStreamingToFile(PP_CompletionCallback callback) {
+  if (!response_info_ || !response_info_->body())
+    return PP_ERROR_FAILED;
+  if (pending_callback_.func)
+    return PP_ERROR_INPROGRESS;
+
+  // We may have already reached EOF.
+  if (done_status_ != PP_ERROR_WOULDBLOCK)
+    return done_status_;
+
+  // Wait for didFinishLoading / didFail.
+  pending_callback_ = callback;
+  return PP_ERROR_WOULDBLOCK;
+}
+
 void URLLoader::Close() {
   NOTIMPLEMENTED();  // TODO(darin): Implement me.
 }
 
 void URLLoader::willSendRequest(WebURLLoader* loader,
                                 WebURLRequest& new_request,
                                 const WebURLResponse& redirect_response) {
   NOTIMPLEMENTED();  // TODO(darin): Allow the plugin to inspect redirects.
 }
 
@@ skipping 29 matching lines @@
 
   buffer_.insert(buffer_.end(), data, data + data_length);
   if (user_buffer_) {
     RunCallback(FillUserBuffer());
   } else {
     DCHECK(!pending_callback_.func);
   }
 }
 
 void URLLoader::didFinishLoading(WebURLLoader* loader) {
-  done_ = true;
-  RunCallback(PP_OK);
+  done_status_ = PP_OK;
+  RunCallback(done_status_);
 }
 
 void URLLoader::didFail(WebURLLoader* loader, const WebURLError& error) {
-  done_ = true;
   // TODO(darin): Provide more detailed error information.
-  RunCallback(PP_ERROR_FAILED);
+  done_status_ = PP_ERROR_FAILED;
+  RunCallback(done_status_);
 }
 
 void URLLoader::RunCallback(int32_t result) {
   if (!pending_callback_.func)
     return;
 
   PP_CompletionCallback callback = {0};
   std::swap(callback, pending_callback_);
   PP_RunCompletionCallback(&callback, result);
 }
 
 size_t URLLoader::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);
 
   // Reset for next time.
   user_buffer_ = NULL;
   user_buffer_size_ = 0;
   return bytes_to_copy;
 }
 
 }  // namespace pepper