Fix URLRequest pepper unit test

ppapi/tests/test_url_request.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.
 //
 // Tests PPB_URLRequestInfo interface.
 
 #include "ppapi/tests/test_url_request.h"
 
 #include <string.h>
 #include <string>
@@ skipping 22 matching lines @@
 const PP_Instance kNotAnInstance = 0xFFFFF0;
 const PP_Resource kNotAResource = 0xAAAAA0;
 }
 
 TestURLRequest::TestURLRequest(TestingInstance* instance)
     : TestCase(instance),
       ppb_url_request_interface_(NULL),
       ppb_url_loader_interface_(NULL),
       ppb_url_response_interface_(NULL),
       ppb_core_interface_(NULL),
-      ppb_var_interface_(NULL),
-      url_loader_(kInvalidResource) {
+      ppb_var_interface_(NULL) {
 }
 
 bool TestURLRequest::Init() {
   ppb_url_request_interface_ = static_cast<const PPB_URLRequestInfo*>(
       pp::Module::Get()->GetBrowserInterface(PPB_URLREQUESTINFO_INTERFACE));
   ppb_url_loader_interface_ = static_cast<const PPB_URLLoader*>(
       pp::Module::Get()->GetBrowserInterface(PPB_URLLOADER_INTERFACE));
   ppb_url_response_interface_ = static_cast<const PPB_URLResponseInfo*>(
       pp::Module::Get()->GetBrowserInterface(PPB_URLRESPONSEINFO_INTERFACE));
   ppb_core_interface_ = static_cast<const PPB_Core*>(
       pp::Module::Get()->GetBrowserInterface(PPB_CORE_INTERFACE));
   ppb_var_interface_ = static_cast<const PPB_Var*>(
       pp::Module::Get()->GetBrowserInterface(PPB_VAR_INTERFACE));
   if (!ppb_url_request_interface_)
     instance_->AppendError("PPB_URLRequestInfo interface not available");
   if (!ppb_url_response_interface_)
     instance_->AppendError("PPB_URLResponseInfo interface not available");
   if (!ppb_core_interface_)
     instance_->AppendError("PPB_Core interface not available");
   if (!ppb_var_interface_)
     instance_->AppendError("PPB_Var interface not available");
   if (!ppb_url_loader_interface_) {
     instance_->AppendError("PPB_URLLoader interface not available");
-  } else {
-    url_loader_ = ppb_url_loader_interface_->Create(instance_->pp_instance());
-    if (url_loader_ == kInvalidResource)
-      instance_->AppendError("Failed to create URLLoader");
   }
   return EnsureRunningOverHTTP();
 }
 
 void TestURLRequest::RunTests(const std::string& filter) {
   RUN_TEST(CreateAndIsURLRequestInfo, filter);
   RUN_TEST(SetProperty, filter);
   RUN_TEST(AppendDataToBody, filter);
   RUN_TEST(AppendFileToBody, filter);
   RUN_TEST(Stress, filter);
@@ skipping 17 matching lines @@
   PP_Resource url_request = ppb_url_request_interface_->Create(
       instance_->pp_instance());
   ASSERT_NE(url_request, kInvalidResource);
 
   // IsURLRequestInfo:
   // Invalid / non-existent / non-URLRequestInfo resource -> false.
   ASSERT_NE(PP_TRUE,
             ppb_url_request_interface_->IsURLRequestInfo(kInvalidResource));
   ASSERT_NE(PP_TRUE,
             ppb_url_request_interface_->IsURLRequestInfo(kNotAResource));
-  ASSERT_NE(PP_TRUE, ppb_url_request_interface_->IsURLRequestInfo(url_loader_));
+
+  PP_Resource url_loader =
+      ppb_url_loader_interface_->Create(instance_->pp_instance());
+  if (url_loader == kInvalidResource) {
+    return "Failed to create URLLoader";

[dmichael (off chromium), 2014/09/19 16:05:12]

ASSERT_NE(kInvalidResource, url_loader);
?

+  }
+  ASSERT_NE(PP_TRUE, ppb_url_request_interface_->IsURLRequestInfo(url_loader));
+  ppb_url_loader_interface_->Close(url_loader);
+  ppb_core_interface_->ReleaseResource(url_loader);
 
   // IsURLRequestInfo: Current URLRequestInfo resource -> true.
   std::string error;
   if (PP_FALSE == ppb_url_request_interface_->IsURLRequestInfo(url_request))
     error = "IsURLRequestInfo() failed with a current URLRequestInfo resource";
 
   // IsURLRequestInfo: Released URLRequestInfo resource -> false.
   ppb_core_interface_->ReleaseResource(url_request);
   ASSERT_NE(PP_TRUE, ppb_url_request_interface_->IsURLRequestInfo(url_request));
 
@@ skipping 162 matching lines @@
     ppb_var_interface_->Release(test_data[i].var);
   }
 
   ppb_core_interface_->ReleaseResource(url_request);
   return error;  // == PASS() if empty.
 }
 
 std::string TestURLRequest::LoadAndCompareBody(
     PP_Resource url_request, const std::string& expected_body) {
   TestCompletionCallback callback(instance_->pp_instance(), PP_REQUIRED);
+
+  PP_Resource url_loader =
+      ppb_url_loader_interface_->Create(instance_->pp_instance());
+  if (url_loader == kInvalidResource) {
+    return "Failed to create URLLoader";

[dmichael (off chromium), 2014/09/19 16:05:12]

ditto

+  }
   callback.WaitForResult(ppb_url_loader_interface_->Open(
-      url_loader_, url_request,
+      url_loader, url_request,
       callback.GetCallback().pp_completion_callback()));
   CHECK_CALLBACK_BEHAVIOR(callback);
   ASSERT_EQ(PP_OK, callback.result());
 
   std::string error;
   PP_Resource url_response =
-      ppb_url_loader_interface_->GetResponseInfo(url_loader_);
+      ppb_url_loader_interface_->GetResponseInfo(url_loader);
   if (url_response == kInvalidResource) {
     error = "PPB_URLLoader::GetResponseInfo() returned invalid resource";
   } else {
     PP_Var status = ppb_url_response_interface_->GetProperty(
         url_response, PP_URLRESPONSEPROPERTY_STATUSCODE);
     if (status.type != PP_VARTYPE_INT32 && status.value.as_int != 200)
       error = ReportError("PPB_URLLoader::Open() status", status.value.as_int);
 
     std::string actual_body;
     for (; error.empty();) {  // Read the entire body in this loop.
       const size_t kBufferSize = 32;
       char buf[kBufferSize];
       callback.WaitForResult(ppb_url_loader_interface_->ReadResponseBody(
-          url_loader_, buf, kBufferSize,
+          url_loader, buf, kBufferSize,
           callback.GetCallback().pp_completion_callback()));
       if (callback.failed())
         error.assign(callback.errors());
       else if (callback.result() < PP_OK)
         error.assign(ReportError("PPB_URLLoader::ReadResponseBody()",
                                  callback.result()));
       if (callback.result() <= PP_OK || callback.failed())
         break;
       actual_body.append(buf, callback.result());
     }
     if (actual_body != expected_body)
       error = "PPB_URLLoader::ReadResponseBody() read unexpected response.";
   }
   ppb_core_interface_->ReleaseResource(url_response);
 
-  ppb_url_loader_interface_->Close(url_loader_);
+  ppb_url_loader_interface_->Close(url_loader);
+  ppb_core_interface_->ReleaseResource(url_loader);
   return error;
 }
 
 // Tests
 //   PP_Bool AppendDataToBody(
 //       PP_Resource request, const void* data, uint32_t len);
 std::string TestURLRequest::TestAppendDataToBody() {
   PP_Resource url_request = ppb_url_request_interface_->Create(
       instance_->pp_instance());
   ASSERT_NE(url_request, kInvalidResource);
@@ skipping 110 matching lines @@
     }
   }
   for (int i = 0; i < num_created; i++) {
     ppb_core_interface_->ReleaseResource(url_request_info[i]);
     if (PP_TRUE ==
         ppb_url_request_interface_->IsURLRequestInfo(url_request_info[i]))
       error = "IsURLREquestInfo() succeeded after release";
   }
   return error;  // == PASS() if empty.
 }