Fix Pepper URL Loader callbacks.

ppapi/tests/test_url_loader.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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>
 
 #include "ppapi/c/dev/ppb_file_io_dev.h"
 #include "ppapi/c/dev/ppb_file_io_trusted_dev.h"
 #include "ppapi/c/dev/ppb_testing_dev.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/ppb_url_loader.h"
 #include "ppapi/cpp/dev/file_io_dev.h"
 #include "ppapi/cpp/dev/file_ref_dev.h"
 #include "ppapi/cpp/dev/file_system_dev.h"
@@ skipping 25 matching lines @@
   RUN_TEST(BasicGET);
   RUN_TEST(BasicPOST);
   RUN_TEST(CompoundBodyPOST);
   RUN_TEST(EmptyDataPOST);
   RUN_TEST(BinaryDataPOST);
   RUN_TEST(CustomRequestHeader);
   RUN_TEST(IgnoresBogusContentLength);
   RUN_TEST(SameOriginRestriction);
   RUN_TEST(StreamToFile);
   RUN_TEST(AuditURLRedirect);
+  RUN_TEST(AbortCalls);
 }
 
 std::string TestURLLoader::ReadEntireFile(pp::FileIO_Dev* file_io,
                                           std::string* data) {
   TestCompletionCallback callback;
   char buf[256];
   int64_t offset = 0;
 
   for (;;) {
     int32_t rv = file_io->Read(offset, buf, sizeof(buf), callback);
     if (rv == PP_ERROR_WOULDBLOCK)
       rv = callback.WaitForResult();
     if (rv < 0)
       return ReportError("FileIO::Read", rv);
     if (rv == 0)
       break;
     offset += rv;
     data->append(buf, rv);
   }
 
-  return "";
+  PASS();
 }
 
 std::string TestURLLoader::ReadEntireResponseBody(pp::URLLoader* loader,
                                                   std::string* body) {
   TestCompletionCallback callback;
-  char buf[256];
+  char buf[2];  // Small so that multiple reads are needed.
 
   for (;;) {
     int32_t rv = loader->ReadResponseBody(buf, sizeof(buf), callback);
     if (rv == PP_ERROR_WOULDBLOCK)
       rv = callback.WaitForResult();
     if (rv < 0)
       return ReportError("URLLoader::ReadResponseBody", rv);
     if (rv == 0)
       break;
     body->append(buf, rv);
   }
 
-  return "";
+  PASS();
 }
 
 std::string TestURLLoader::LoadAndCompareBody(
     const pp::URLRequestInfo& request,
     const std::string& expected_body) {
   TestCompletionCallback callback;
 
   pp::URLLoader loader(*instance_);
   int32_t rv = loader.Open(request, callback);
   if (rv == PP_ERROR_WOULDBLOCK)
@@ skipping 11 matching lines @@
   std::string body;
   std::string error = ReadEntireResponseBody(&loader, &body);
   if (!error.empty())
     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";
 
-  return "";
+  PASS();
 }
 
 std::string TestURLLoader::TestBasicGET() {
   pp::URLRequestInfo request;
   request.SetURL("test_url_loader_data/hello.txt");
   return LoadAndCompareBody(request, "hello\n");
 }
 
 std::string TestURLLoader::TestBasicPOST() {
   pp::URLRequestInfo request;
@@ skipping 154 matching lines @@
   // is correct.
   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 != 301)
     return "Response status should be 301";
   if (response_info.GetRedirectURL().AsString() != "www.google.com")
     return "Redirect URL should be www.google.com";
 
-  return "";
+  PASS();
 }
 
+std::string TestURLLoader::TestAbortCalls() {
+  pp::URLRequestInfo request;
+  request.SetURL("test_url_loader_data/hello.txt");
+
+  TestCompletionCallback callback;
+  int32_t rv;
+
+  // Abort |Open()|.
+  {
+    callback.reset_run_count();
+    rv = pp::URLLoader(*instance_).Open(request, callback);
+    if (callback.run_count() > 0)
+      return "URLLoader::Open ran callback synchronously.";
+    if (rv == PP_ERROR_WOULDBLOCK) {
+      rv = callback.WaitForResult();
+      if (rv != PP_ERROR_ABORTED)
+        return "URLLoader::Open not aborted.";
+    } else if (rv != PP_OK) {
+      return ReportError("URLLoader::Open", rv);
+    }
+  }
+
+  // Abort |ReadResponseBody()|.
+  {
+    char buf[2] = { 0 };
+    {
+      pp::URLLoader loader(*instance_);
+      rv = loader.Open(request, callback);
+      if (rv == PP_ERROR_WOULDBLOCK)
+        rv = callback.WaitForResult();
+      if (rv != PP_OK)
+        return ReportError("URLLoader::Open", rv);
+
+      callback.reset_run_count();
+      rv = loader.ReadResponseBody(buf, sizeof(buf), callback);
+    }  // Destroy |loader|.
+    if (rv == PP_ERROR_WOULDBLOCK) {
+      // Save a copy and make sure |buf| doesn't get written to.
+      char buf_copy[2];
+      memcpy(&buf_copy, &buf, sizeof(buf));
+      rv = callback.WaitForResult();
+      if (rv != PP_ERROR_ABORTED)
+        return "URLLoader::ReadResponseBody not aborted.";
+      if (memcmp(&buf_copy, &buf, sizeof(buf)) != 0)
+        return "URLLoader::ReadResponseBody wrote data after resource "
+               "destruction.";
+    } else if (rv != PP_OK) {
+      return ReportError("URLLoader::ReadResponseBody", rv);
+    }
+  }
+
+  // TODO(viettrungluu): More abort tests (but add basic tests first).
+  // Also test that Close() aborts properly. crbug.com/69457
+
+  PASS();
+}
+
+// TODO(viettrungluu): Add tests for FollowRedirect,
+// Get{Upload,Download}Progress, Close (including abort tests if applicable).
 // TODO(darin): Add a test for GrantUniversalAccess.