Convert resources to take an instance key instead of an Instance*.

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 151 matching lines @@
   }
 
   PASS();
 }
 
 std::string TestURLLoader::LoadAndCompareBody(
     const pp::URLRequestInfo& request,
     const std::string& expected_body) {
   TestCompletionCallback callback(instance_->pp_instance(), force_async_);
 
-  pp::URLLoader loader(*instance_);
+  pp::URLLoader loader(instance_);
   int32_t rv = loader.Open(request, callback);
   if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
     return ReportError("URLLoader::Open force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("URLLoader::Open", rv);
 
   pp::URLResponseInfo response_info(loader.GetResponseInfo());
   if (response_info.is_null())
@@ skipping 61 matching lines @@
   }
 
   return rv;
 }
 
 std::string TestURLLoader::GetReachableAbsoluteURL(
     const std::string& file_name) {
   // Get the absolute page URL and replace the test case file name
   // with the given one.
   pp::Var document_url(
-      pp::Var::PassRef(),
+      pp::PASS_REF,
       testing_interface_->GetDocumentURL(instance_->pp_instance(),
                                          NULL));
   std::string url(document_url.AsString());
   std::string old_name("test_case.html");
   size_t index = url.find(old_name);
   ASSERT_NE(index, std::string::npos);
   url.replace(index, old_name.length(), file_name);
   return url;
 }
 
@@ skipping 34 matching lines @@
 int32_t TestURLLoader::OpenUntrusted(const pp::URLRequestInfo& request) {
   return Open(request, false);
 }
 
 int32_t TestURLLoader::OpenTrusted(const pp::URLRequestInfo& request) {
   return Open(request, true);
 }
 
 int32_t TestURLLoader::Open(const pp::URLRequestInfo& request,
                             bool trusted) {
-  pp::URLLoader loader(*instance_);
+  pp::URLLoader loader(instance_);
   if (trusted)
     url_loader_trusted_interface_->GrantUniversalAccess(loader.pp_resource());
   TestCompletionCallback callback(instance_->pp_instance(), force_async_);
   int32_t rv = loader.Open(request, callback);
 
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   else if (force_async_)
     ReportError("URLLoader::Open force_async", rv);
 
@@ skipping 112 matching lines @@
   PASS();
 }
 
 std::string TestURLLoader::TestStreamToFile() {
   pp::URLRequestInfo request(instance_);
   request.SetURL("test_url_loader_data/hello.txt");
   request.SetStreamToFile(true);
 
   TestCompletionCallback callback(instance_->pp_instance(), force_async_);
 
-  pp::URLLoader loader(*instance_);
+  pp::URLLoader loader(instance_);
   int32_t rv = loader.Open(request, callback);
   if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
     return ReportError("URLLoader::Open force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("URLLoader::Open", rv);
 
   pp::URLResponseInfo response_info(loader.GetResponseInfo());
   if (response_info.is_null())
@@ skipping 268 matching lines @@
   // This prefix causes the test server to return a 301 redirect.
   std::string redirect_prefix("/server-redirect?");
   // We need an absolute path for the redirect to actually work.
   std::string redirect_url =
       GetReachableAbsoluteURL("test_url_loader_data/hello.txt");
   request.SetURL(redirect_prefix.append(redirect_url));
   request.SetFollowRedirects(false);
 
   TestCompletionCallback callback(instance_->pp_instance(), force_async_);
 
-  pp::URLLoader loader(*instance_);
+  pp::URLLoader loader(instance_);
   int32_t rv = loader.Open(request, callback);
   if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
     return ReportError("URLLoader::Open force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("URLLoader::Open", rv);
 
   // Checks that the response indicates a redirect, and that the URL
   // is correct.
@@ skipping 28 matching lines @@
 std::string TestURLLoader::TestAbortCalls() {
   pp::URLRequestInfo request(instance_);
   request.SetURL("test_url_loader_data/hello.txt");
 
   TestCompletionCallback callback(instance_->pp_instance(), force_async_);
   int32_t rv;
 
   // Abort |Open()|.
   {
     callback.reset_run_count();
-    rv = pp::URLLoader(*instance_).Open(request, callback);
+    rv = pp::URLLoader(instance_).Open(request, callback);
     if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
       return ReportError("URLLoader::Open force_async", rv);
     if (callback.run_count() > 0)
       return "URLLoader::Open ran callback synchronously.";
     if (rv == PP_OK_COMPLETIONPENDING) {
       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_);
+      pp::URLLoader loader(instance_);
       rv = loader.Open(request, callback);
       if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
         return ReportError("URLLoader::Open force_async", rv);
       if (rv == PP_OK_COMPLETIONPENDING)
         rv = callback.WaitForResult();
       if (rv != PP_OK)
         return ReportError("URLLoader::Open", rv);
 
       callback.reset_run_count();
       rv = loader.ReadResponseBody(buf, sizeof(buf), callback);
@@ skipping 20 matching lines @@
 
   PASS();
 }
 
 std::string TestURLLoader::TestUntendedLoad() {
   pp::URLRequestInfo request(instance_);
   request.SetURL("test_url_loader_data/hello.txt");
   request.SetRecordDownloadProgress(true);
   TestCompletionCallback callback(instance_->pp_instance(), force_async_);
 
-  pp::URLLoader loader(*instance_);
+  pp::URLLoader loader(instance_);
   int32_t rv = loader.Open(request, callback);
   if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
     return ReportError("URLLoader::Open force_async", rv);
   if (rv == PP_OK_COMPLETIONPENDING)
     rv = callback.WaitForResult();
   if (rv != PP_OK)
     return ReportError("URLLoader::Open", rv);
 
   // We received the response callback. Yield until the network code has called
   // the loader's didReceiveData and didFinishLoading methods before we give it
@@ skipping 49 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).