Provide a safer URLLoader ReadResponseBody API

ppapi/cpp/url_loader.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/cpp/url_loader.h"
 
+#include <string.h>  // memcpy
+
 #include "ppapi/c/ppb_url_loader.h"
 #include "ppapi/c/pp_errors.h"
-#include "ppapi/cpp/completion_callback.h"
 #include "ppapi/cpp/file_ref.h"
 #include "ppapi/cpp/instance_handle.h"
 #include "ppapi/cpp/module.h"
 #include "ppapi/cpp/module_impl.h"
 #include "ppapi/cpp/url_request_info.h"
 #include "ppapi/cpp/url_response_info.h"
 
 namespace pp {
 
 namespace {
 
+template <> const char* interface_name<PPB_URLLoader_1_1>() {
+  return PPB_URLLOADER_INTERFACE_1_1;
+}
+
 template <> const char* interface_name<PPB_URLLoader_1_0>() {
   return PPB_URLLOADER_INTERFACE_1_0;
 }
 
 }  // namespace
 
 URLLoader::URLLoader(PP_Resource resource) : Resource(resource) {
 }
 
 URLLoader::URLLoader(const InstanceHandle& instance) {
-  if (!has_interface<PPB_URLLoader_1_0>())
-    return;
-  PassRefFromConstructor(get_interface<PPB_URLLoader_1_0>()->Create(
-      instance.pp_instance()));
+  if (has_interface<PPB_URLLoader_1_1>()) {
+    PassRefFromConstructor(get_interface<PPB_URLLoader_1_1>()->Create(
+        instance.pp_instance()));
+  } else if (has_interface<PPB_URLLoader_1_0>()) {
+    PassRefFromConstructor(get_interface<PPB_URLLoader_1_0>()->Create(
+        instance.pp_instance()));
+  }
 }
 
 URLLoader::URLLoader(const URLLoader& other) : Resource(other) {
 }
 
 int32_t URLLoader::Open(const URLRequestInfo& request_info,
                         const CompletionCallback& cc) {
-  if (!has_interface<PPB_URLLoader_1_0>())
-    return cc.MayForce(PP_ERROR_NOINTERFACE);
-  return get_interface<PPB_URLLoader_1_0>()->Open(pp_resource(),
-                                              request_info.pp_resource(),
-                                              cc.pp_completion_callback());
+  if (has_interface<PPB_URLLoader_1_1>()) {
+    return get_interface<PPB_URLLoader_1_1>()->Open(
+        pp_resource(), request_info.pp_resource(), cc.pp_completion_callback());
+  } else if (has_interface<PPB_URLLoader_1_0>()) {
+    return get_interface<PPB_URLLoader_1_0>()->Open(
+        pp_resource(), request_info.pp_resource(), cc.pp_completion_callback());
+  }
+  return cc.MayForce(PP_ERROR_NOINTERFACE);
 }
 
 int32_t URLLoader::FollowRedirect(const CompletionCallback& cc) {
-  if (!has_interface<PPB_URLLoader_1_0>())
-    return cc.MayForce(PP_ERROR_NOINTERFACE);
-  return get_interface<PPB_URLLoader_1_0>()->FollowRedirect(
-      pp_resource(), cc.pp_completion_callback());
+  if (has_interface<PPB_URLLoader_1_1>()) {
+    return get_interface<PPB_URLLoader_1_1>()->FollowRedirect(
+        pp_resource(), cc.pp_completion_callback());
+  } else if (has_interface<PPB_URLLoader_1_0>()) {
+    return get_interface<PPB_URLLoader_1_0>()->FollowRedirect(
+        pp_resource(), cc.pp_completion_callback());
+  }
+  return cc.MayForce(PP_ERROR_NOINTERFACE);
 }
 
 bool URLLoader::GetUploadProgress(int64_t* bytes_sent,
                                   int64_t* total_bytes_to_be_sent) const {
-  if (!has_interface<PPB_URLLoader_1_0>())
-    return false;
-  return PP_ToBool(get_interface<PPB_URLLoader_1_0>()->GetUploadProgress(
-      pp_resource(), bytes_sent, total_bytes_to_be_sent));
+  if (has_interface<PPB_URLLoader_1_1>()) {
+    return PP_ToBool(get_interface<PPB_URLLoader_1_1>()->GetUploadProgress(
+        pp_resource(), bytes_sent, total_bytes_to_be_sent));
+  } else if (has_interface<PPB_URLLoader_1_0>()) {
+    return PP_ToBool(get_interface<PPB_URLLoader_1_0>()->GetUploadProgress(
+        pp_resource(), bytes_sent, total_bytes_to_be_sent));
+  }
+  return false;
 }
 
 bool URLLoader::GetDownloadProgress(
     int64_t* bytes_received,
     int64_t* total_bytes_to_be_received) const {
-  if (!has_interface<PPB_URLLoader_1_0>())
-    return false;
-  return PP_ToBool(get_interface<PPB_URLLoader_1_0>()->GetDownloadProgress(
-      pp_resource(), bytes_received, total_bytes_to_be_received));
+  if (has_interface<PPB_URLLoader_1_1>()) {
+    return PP_ToBool(get_interface<PPB_URLLoader_1_1>()->GetDownloadProgress(
+        pp_resource(), bytes_received, total_bytes_to_be_received));
+  } else if (has_interface<PPB_URLLoader_1_0>()) {
+    return PP_ToBool(get_interface<PPB_URLLoader_1_0>()->GetDownloadProgress(
+        pp_resource(), bytes_received, total_bytes_to_be_received));
+  }
+  return false;
 }
 
 URLResponseInfo URLLoader::GetResponseInfo() const {
-  if (!has_interface<PPB_URLLoader_1_0>())
-    return URLResponseInfo();
-  return URLResponseInfo(PASS_REF,
-                         get_interface<PPB_URLLoader_1_0>()->GetResponseInfo(
-                             pp_resource()));
+  if (has_interface<PPB_URLLoader_1_1>()) {
+    return URLResponseInfo(PASS_REF,
+                           get_interface<PPB_URLLoader_1_1>()->GetResponseInfo(
+                               pp_resource()));
+  } else if (has_interface<PPB_URLLoader_1_0>()) {
+    return URLResponseInfo(PASS_REF,
+                           get_interface<PPB_URLLoader_1_0>()->GetResponseInfo(
+                               pp_resource()));
+  }
+  return URLResponseInfo();
 }
 
 int32_t URLLoader::ReadResponseBody(void* buffer,
                                     int32_t bytes_to_read,
                                     const CompletionCallback& cc) {
-  if (!has_interface<PPB_URLLoader_1_0>())
-    return cc.MayForce(PP_ERROR_NOINTERFACE);
-  return get_interface<PPB_URLLoader_1_0>()->ReadResponseBody(
-      pp_resource(), buffer, bytes_to_read, cc.pp_completion_callback());
+  if (has_interface<PPB_URLLoader_1_1>()) {
+    return get_interface<PPB_URLLoader_1_1>()->ReadResponseBody(
+        pp_resource(), buffer, bytes_to_read, cc.pp_completion_callback());
+  } else if (has_interface<PPB_URLLoader_1_0>()) {
+    return get_interface<PPB_URLLoader_1_0>()->ReadResponseBody(
+        pp_resource(), buffer, bytes_to_read, cc.pp_completion_callback());
+  }
+  return cc.MayForce(PP_ERROR_NOINTERFACE);
+}
+
+int32_t URLLoader::ReadResponseBody(
+    int32_t max_read_length,
+    const CompletionCallbackWithOutput< std::vector<char> >& cc) {
+  if (has_interface<PPB_URLLoader_1_1>()) {
+    PP_ArrayOutput array_output = cc.output();
+    return get_interface<PPB_URLLoader_1_1>()->ReadResponseBodyToArray(
+        pp_resource(), max_read_length, &array_output,
+        cc.pp_completion_callback());
+  } else if (has_interface<PPB_URLLoader_1_0>()) {
+    // Data for our callback wrapper. The callback handler will delete it and
+    // temp_buffer.
+    CallbackData1_0* data = new CallbackData1_0;
+    data->output = cc.output();
+    data->temp_buffer = max_read_length >= 0 ? new char[max_read_length] : NULL;
+    data->original_callback = cc.pp_completion_callback();
+
+    // Actual returned bytes might not equals to max_read_length.  We need to
+    // read to a temporary buffer first and copy later to make sure the array
+    // buffer has correct size.
+    return get_interface<PPB_URLLoader_1_0>()->ReadResponseBody(
+        pp_resource(), data->temp_buffer, max_read_length,
+        PP_MakeCompletionCallback(&CallbackConverter, data));
+  }
+  return cc.MayForce(PP_ERROR_NOINTERFACE);
 }
 
 int32_t URLLoader::FinishStreamingToFile(const CompletionCallback& cc) {
-  if (!has_interface<PPB_URLLoader_1_0>())
-    return cc.MayForce(PP_ERROR_NOINTERFACE);
-  return get_interface<PPB_URLLoader_1_0>()->FinishStreamingToFile(
-      pp_resource(), cc.pp_completion_callback());
+  if (has_interface<PPB_URLLoader_1_1>()) {
+    return get_interface<PPB_URLLoader_1_1>()->FinishStreamingToFile(
+        pp_resource(), cc.pp_completion_callback());
+  } else if (has_interface<PPB_URLLoader_1_0>()) {
+    return get_interface<PPB_URLLoader_1_0>()->FinishStreamingToFile(
+        pp_resource(), cc.pp_completion_callback());
+  }
+  return cc.MayForce(PP_ERROR_NOINTERFACE);
 }
 
 void URLLoader::Close() {
-  if (!has_interface<PPB_URLLoader_1_0>())
-    return;
-  get_interface<PPB_URLLoader_1_0>()->Close(pp_resource());
+  if (has_interface<PPB_URLLoader_1_1>())
+    get_interface<PPB_URLLoader_1_1>()->Close(pp_resource());
+  else if (has_interface<PPB_URLLoader_1_0>())
+    get_interface<PPB_URLLoader_1_0>()->Close(pp_resource());
+}
+
+// static
+void URLLoader::CallbackConverter(void* user_data, int32_t result) {
+  CallbackData1_0* data = static_cast<CallbackData1_0*>(user_data);
+
+  if (result >= 0) {
+    // Copy to the destination buffer owned by the callback.
+    char* buffer = static_cast<char*>(data->output.GetDataBuffer(
+        data->output.user_data, result, sizeof(char)));
+    memcpy(buffer, data->temp_buffer, result);
+    delete[] data->temp_buffer;
+  }
+
+  // Now execute the original callback.
+  PP_RunCompletionCallback(&data->original_callback, result);
+  delete data;
 }
 
 }  // namespace pp