Provide a safer URLLoader ReadResponseBody API

ppapi/tests/test_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/tests/test_url_loader.h"
 
 #include <stdio.h>
 #include <string.h>
 #include <string>
 
@@ skipping 79 matching lines @@
       instance_->AppendError("FileIOTrusted interface is supported by NaCl");
     if (url_loader_trusted_interface_)
       instance_->AppendError("URLLoaderTrusted interface is supported by NaCl");
 #endif
   }
   return EnsureRunningOverHTTP();
 }
 
 void TestURLLoader::RunTests(const std::string& filter) {
   RUN_CALLBACK_TEST(TestURLLoader, BasicGET, filter);
+  RUN_CALLBACK_TEST(TestURLLoader, BasicGET_ToArray, filter);
   RUN_CALLBACK_TEST(TestURLLoader, BasicPOST, filter);
   RUN_CALLBACK_TEST(TestURLLoader, BasicFilePOST, filter);
   RUN_CALLBACK_TEST(TestURLLoader, BasicFileRangePOST, filter);
   RUN_CALLBACK_TEST(TestURLLoader, CompoundBodyPOST, filter);
   RUN_CALLBACK_TEST(TestURLLoader, EmptyDataPOST, filter);
   RUN_CALLBACK_TEST(TestURLLoader, BinaryDataPOST, filter);
   RUN_CALLBACK_TEST(TestURLLoader, CustomRequestHeader, filter);
   RUN_CALLBACK_TEST(TestURLLoader, FailsBogusContentLength, filter);
   RUN_CALLBACK_TEST(TestURLLoader, StreamToFile, filter);
   RUN_CALLBACK_TEST(TestURLLoader, UntrustedSameOriginRestriction, filter);
@@ skipping 41 matching lines @@
     if (callback.result() < 0)
       return ReportError("URLLoader::ReadResponseBody", callback.result());
     if (callback.result() == 0)
       break;
     body->append(buf, callback.result());
   }
 
   PASS();
 }
 
+std::string TestURLLoader::ReadEntireResponseBodyToArray(pp::URLLoader* loader,
+                                                         std::string* body) {
+  TestCompletionCallbackWithOutput< std::vector<char> > callback(
+      instance_->pp_instance(), callback_type());
+
+  for (;;) {
+    // Read just a little bit so that multiple reads are needed.
+    callback.WaitForResult(loader->ReadResponseBody(2, callback));
+    int32_t rv = callback.result();
+    if (rv < 0)
+      return ReportError("URLLoader::ReadResponseBody", rv);
+    if (rv == 0)
+      break;
+    assert(rv == static_cast<int32_t>(callback.output().size()));
+    body->append(callback.output().begin(), callback.output().end());
+  }
+
+  PASS();
+}
+
 std::string TestURLLoader::LoadAndCompareBody(
     const pp::URLRequestInfo& request,
     const std::string& expected_body) {
   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
 
   pp::URLLoader loader(instance_);
   callback.WaitForResult(loader.Open(request, callback));
   CHECK_CALLBACK_BEHAVIOR(callback);
   ASSERT_EQ(PP_OK, callback.result());
 
@@ skipping 10 matching lines @@
     return error;
 
   if (body.size() != expected_body.size())
     return "URLLoader::ReadResponseBody returned unexpected content length";
   if (body != expected_body)
     return "URLLoader::ReadResponseBody returned unexpected content";
 
   PASS();
 }
 
+// Exact the same test of LoadAndCompareBody, but for ReadResponseBodyToArray.
+std::string TestURLLoader::LoadAndCompareBody_ToArray(
+    const pp::URLRequestInfo& request,
+    const std::string& expected_body) {
+  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+
+  pp::URLLoader loader(instance_);
+  callback.WaitForResult(loader.Open(request, callback));
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_EQ(PP_OK, callback.result());
+
+  pp::URLResponseInfo response_info(loader.GetResponseInfo());
+  if (response_info.is_null())
+    return "URLLoader::GetResponseInfo returned null";
+  int32_t status_code = response_info.GetStatusCode();
+  if (status_code != 200)
+    return "Unexpected HTTP status code";
+
+  std::string body;
+  std::string error = ReadEntireResponseBodyToArray(&loader, &body);
+  if (!error.empty())
+    return error;
+
+  if (body.size() != expected_body.size())
+    return "URLLoader::ReadResponseBodyToArray returned unexpected content "
+           "length";
+  if (body != expected_body)
+    return "URLLoader::ReadResponseBodyToArray returned unexpected content";
+
+  PASS();
+}
+
 int32_t TestURLLoader::OpenFileSystem(pp::FileSystem* file_system,
                                       std::string* message) {
   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
   callback.WaitForResult(file_system->Open(1024, callback));
   if (callback.failed()) {
     message->assign(callback.errors());
     return callback.result();
   }
   if (callback.result() != PP_OK) {
     message->assign("FileSystem::Open");
@@ skipping 99 matching lines @@
   callback.WaitForResult(loader.Open(request, callback));
   return callback.result();
 }
 
 std::string TestURLLoader::TestBasicGET() {
   pp::URLRequestInfo request(instance_);
   request.SetURL("test_url_loader_data/hello.txt");
   return LoadAndCompareBody(request, "hello\n");
 }
 
+// A variance of BasicGET but use ReadResponseBodyToArray internally.
+std::string TestURLLoader::TestBasicGET_ToArray() {
+  pp::URLRequestInfo request(instance_);
+  request.SetURL("test_url_loader_data/hello.txt");
+  return LoadAndCompareBody_ToArray(request, "hello\n");
+}
+
 std::string TestURLLoader::TestBasicPOST() {
   pp::URLRequestInfo request(instance_);
   request.SetURL("/echo");
   request.SetMethod("POST");
   std::string postdata("postdata");
   request.AppendDataToBody(postdata.data(), postdata.length());
   return LoadAndCompareBody(request, postdata);
 }
 
 std::string TestURLLoader::TestBasicFilePOST() {
@@ skipping 516 matching lines @@
   if (rv != PP_ERROR_FAILED) {
     return ReportError("The lower buffer value was higher than the upper but "
                        "the URLLoader did not fail.", rv);
   }
 
   PASS();
 }
 
 // TODO(viettrungluu): Add tests for  Get{Upload,Download}Progress, Close
 // (including abort tests if applicable).