Added bounds checks to the URLLoader prefetch buffer threshhold.

ppapi/tests/test_url_loader.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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>
 
 #include "ppapi/c/dev/ppb_testing_dev.h"
@@ skipping 98 matching lines @@
   RUN_TEST_FORCEASYNC_AND_NOT(UntrustedCrossOriginRequest, filter);
   RUN_TEST_FORCEASYNC_AND_NOT(TrustedCrossOriginRequest, filter);
   RUN_TEST_FORCEASYNC_AND_NOT(UntrustedJavascriptURLRestriction, filter);
   RUN_TEST_FORCEASYNC_AND_NOT(TrustedJavascriptURLRestriction, filter);
   RUN_TEST_FORCEASYNC_AND_NOT(UntrustedHttpRequests, filter);
   RUN_TEST_FORCEASYNC_AND_NOT(TrustedHttpRequests, filter);
   RUN_TEST_FORCEASYNC_AND_NOT(FollowURLRedirect, filter);
   RUN_TEST_FORCEASYNC_AND_NOT(AuditURLRedirect, filter);
   RUN_TEST_FORCEASYNC_AND_NOT(AbortCalls, filter);
   RUN_TEST_FORCEASYNC_AND_NOT(UntendedLoad, filter);
+  RUN_TEST_FORCEASYNC_AND_NOT(NegativePrefetchBufferThreshold, filter);
+  RUN_TEST_FORCEASYNC_AND_NOT(LegalPrefetchBufferThreshold, filter);
+  RUN_TEST_FORCEASYNC_AND_NOT(InvertedPrefetchBufferThreshold, filter);
 }
 
 std::string TestURLLoader::ReadEntireFile(pp::FileIO* file_io,
                                           std::string* data) {
   TestCompletionCallback callback(instance_->pp_instance(), force_async_);
   char buf[256];
   int64_t offset = 0;
 
   for (;;) {
     int32_t rv = file_io->Read(offset, buf, sizeof(buf), callback);
@@ skipping 734 matching lines @@
   std::string body;
   std::string error = ReadEntireResponseBody(&loader, &body);
   if (!error.empty())
     return error;
   if (body != "hello\n")
     return ReportError("Couldn't read data", rv);
 
   PASS();
 }
 
+int32_t TestURLLoader::OpenWithPrefetchBufferThreshold(int32_t lower,
+                                                       int32_t upper) {
+  pp::URLRequestInfo request(instance_);
+  request.SetURL("test_url_loader_data/hello.txt");
+  request.SetPrefetchBufferLowerThreshold(lower);
+  request.SetPrefetchBufferUpperThreshold(upper);
+
+  int32_t rv = OpenUntrusted(request);
+  return rv;
+}
+
+std::string TestURLLoader::TestNegativePrefetchBufferThreshold() {
+  int32_t rv = OpenWithPrefetchBufferThreshold(-1, 1);
+  if (rv != PP_ERROR_FAILED) {
+    return ReportError("The prefetch limits contained a negative value but "
+                       "the URLLoader did not fail.", rv);
+  }
+
+  PASS();
+}
+
+std::string TestURLLoader::TestLegalPrefetchBufferThreshold() {
+  int32_t rv = OpenWithPrefetchBufferThreshold(0, 1);
+  if (rv != PP_OK) {
+    return ReportError("The prefetch buffer limits were legal values but "
+                       "the URLLoader failed.", rv);
+  }
+
+  PASS();
+}
+
+std::string TestURLLoader::TestInvertedPrefetchBufferThreshold() {
+  int32_t rv = OpenWithPrefetchBufferThreshold(1000, 1);
+  if (rv != PP_ERROR_FAILED) {
+    return ReportError("The lower buffer value was higher than the upper but "
+                       "the URLLoader did not fail.", rv);
+  }
+

[dmichael (off chromium), 2012/01/13 17:46:02]

I think it would make sense to collapse these in to just one
"TestPrefetchBufferThreshold" test.

It's a balancing act, but each of these tests requires starting up and shutting
down chrome, so we probably shouldn't make them quite this fine-grained, lest we
make the suite of ppapi tests too slow on the bots.

+  PASS();
+}
+
 // TODO(viettrungluu): Add tests for  Get{Upload,Download}Progress, Close
 // (including abort tests if applicable).