Pepper: Move FileRef to the "new" resource proxy.

ppapi/proxy/url_loader_resource.cc

 // Copyright (c) 2013 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/proxy/url_loader_resource.h"
 
+#include "base/debug/stack_trace.h"

[yzshen1, 2013/08/08 23:16:21]

It seems we don't need it?

[teravest, 2013/08/09 02:00:08]

Done.

 #include "base/logging.h"
 #include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/ppb_url_loader.h"
 #include "ppapi/proxy/dispatch_reply_message.h"
+#include "ppapi/proxy/file_ref_resource.h"
 #include "ppapi/proxy/ppapi_messages.h"
-#include "ppapi/proxy/ppb_file_ref_proxy.h"
 #include "ppapi/proxy/url_request_info_resource.h"
 #include "ppapi/proxy/url_response_info_resource.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
 #include "ppapi/shared_impl/url_response_info_data.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/resource_creation_api.h"
 
 using ppapi::thunk::EnterResourceNoLock;
 using ppapi::thunk::PPB_URLLoader_API;
 using ppapi::thunk::PPB_URLRequestInfo_API;
@@ skipping 127 matching lines @@
   return 0;
 }
 
 int32_t URLLoaderResource::ReadResponseBody(
     void* buffer,
     int32_t bytes_to_read,
     scoped_refptr<TrackedCallback> callback) {
   int32_t rv = ValidateCallback(callback);
   if (rv != PP_OK)
     return rv;
-  if (!response_info_.get() ||
-      !response_info_->data().body_as_file_ref.resource.is_null())
+  if (!response_info_.get())
     return PP_ERROR_FAILED;
+
+  // Fail if we have a valid file ref.
+  // ReadResponseBody() is for reading to a user-provided buffer.
+  if (response_info_->data().body_as_file_ref.IsValid())
+    return PP_ERROR_FAILED;
+
   if (bytes_to_read <= 0 || !buffer)
     return PP_ERROR_BADARGUMENT;
 
   user_buffer_ = static_cast<char*>(buffer);
   user_buffer_size_ = bytes_to_read;
 
   if (!buffer_.empty())
     return FillUserBuffer();
 
   // We may have already reached EOF.
   if (done_status_ != PP_OK_COMPLETIONPENDING) {
     user_buffer_ = NULL;
     user_buffer_size_ = 0;
     return done_status_;
   }
 
   RegisterCallback(callback);
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t URLLoaderResource::FinishStreamingToFile(
     scoped_refptr<TrackedCallback> callback) {
   int32_t rv = ValidateCallback(callback);
   if (rv != PP_OK)
     return rv;
-  if (!response_info_.get() ||
-      response_info_->data().body_as_file_ref.resource.is_null())
+  if (!response_info_.get())
+    return PP_ERROR_FAILED;
+
+  // Fail if we do not have a valid file ref.
+  if (!response_info_->data().body_as_file_ref.IsValid())
     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_)
     SetDefersLoading(false);
 
@@ skipping 149 matching lines @@
   // As a second line of defense, clear the |user_buffer_| in case the
   // callbacks get called in an unexpected order.
   user_buffer_ = NULL;
   user_buffer_size_ = 0;
   pending_callback_->Run(result);
 }
 
 void URLLoaderResource::SaveResponseInfo(const URLResponseInfoData& data) {
   // Create a proxy resource for the the file ref host resource if needed.
   PP_Resource body_as_file_ref = 0;
-  if (!data.body_as_file_ref.resource.is_null()) {
-    thunk::EnterResourceCreationNoLock enter(pp_instance());
-    body_as_file_ref =
-        enter.functions()->CreateFileRef(data.body_as_file_ref);
+  if (data.body_as_file_ref.IsValid()) {
+    body_as_file_ref = FileRefResource::CreateFileRef(connection(),
+                                                      pp_instance(),
+                                                      data.body_as_file_ref);
   }
   response_info_ = new URLResponseInfoResource(
       connection(), pp_instance(), data, body_as_file_ref);
 }
 
 size_t URLLoaderResource::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.
   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();
     SetDefersLoading(false);
   }
 
   // Reset for next time.
   user_buffer_ = NULL;
   user_buffer_size_ = 0;
   return bytes_to_copy;
 }
 
 }  // namespace proxy
-}  // namespace ppapi
+}  // namespace ppapi