ppapi_proxy: Support loading and reading urls. Proxy URLLoader....

tests/ppapi_geturl/url_load_request.cc

 // Copyright 2010 The Native Client 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 "native_client/tests/ppapi_geturl/url_load_request.h"
 
 #include <stdio.h>
 #include <string>
 #include <sstream>
 
 #include "native_client/src/include/portability.h"
 #include "native_client/src/include/nacl_macros.h"
 #include "native_client/src/shared/platform/nacl_check.h"
 #include "native_client/tests/ppapi_geturl/module.h"
+#include "ppapi/c/pp_bool.h"
 #include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/pp_errors.h"
 
 namespace {
 
+// A local helper that does not contribute to loading/reading of urls, but
+// allows us to test proxying of Is<Interface> functions.
+// TODO(polina): when we have unit tests, move this there.
+void TestIsInterface(std::string test_interface,
+                     PP_Resource resource,
+                     const PPB_URLRequestInfo* ppb_url_request_info,
+                     const PPB_URLResponseInfo* ppb_url_response_info,
+                     const PPB_URLLoader* ppb_url_loader) {
+  printf("--- TestIsInterface: %s\n", test_interface.c_str());
+  if (test_interface == PPB_URLREQUESTINFO_INTERFACE) {
+    CHECK(ppb_url_request_info->IsURLRequestInfo(resource) == PP_TRUE);
+    CHECK(ppb_url_response_info->IsURLResponseInfo(resource) == PP_FALSE);
+    CHECK(ppb_url_loader->IsURLLoader(resource) == PP_FALSE);
+  } else if (test_interface == PPB_URLRESPONSEINFO_INTERFACE) {
+    CHECK(ppb_url_request_info->IsURLRequestInfo(resource) == PP_FALSE);
+    CHECK(ppb_url_response_info->IsURLResponseInfo(resource) == PP_TRUE);
+    CHECK(ppb_url_loader->IsURLLoader(resource) == PP_FALSE);
+  } else if (test_interface == PPB_URLLOADER_INTERFACE) {
+    CHECK(ppb_url_request_info->IsURLRequestInfo(resource) == PP_FALSE);
+    CHECK(ppb_url_response_info->IsURLResponseInfo(resource) == PP_FALSE);
+    CHECK(ppb_url_loader->IsURLLoader(resource) == PP_TRUE);
+  }
+}
+
 void OpenCallback(void* user_data, int32_t pp_error) {
   UrlLoadRequest* obj = reinterpret_cast<UrlLoadRequest*>(user_data);
   if (NULL != obj)
     obj->OpenCallback(pp_error);
 }
 
 void FinishStreamingToFileCallback(void* user_data, int32_t pp_error) {
   UrlLoadRequest* obj = reinterpret_cast<UrlLoadRequest*>(user_data);
   if (NULL != obj)
     obj->FinishStreamingToFileCallback(pp_error);
@@ skipping 131 matching lines @@
   if (NULL == loader_interface_) {
     *error = "Failed to get browser interface '" PPB_URLLOADER_INTERFACE;
     return false;
   }
   loader_ = loader_interface_->Create(instance_);
   if (0 == loader_) {
     *error = "PPB_URLLoader::Create: failed";
     return false;
   }
 
+  TestIsInterface(PPB_URLREQUESTINFO_INTERFACE, request_,
+                  request_interface_, response_interface_, loader_interface_);
+  TestIsInterface(PPB_URLLOADER_INTERFACE, loader_,
+                  request_interface_, response_interface_, loader_interface_);
+
+  // TODO(sanga): enable this for untrusted code when FileIO proxy is supported.
 #if !defined(__native_client__)
   fileio_interface_ = static_cast<const PPB_FileIO_Dev*>(
       module->GetBrowserInterface(PPB_FILEIO_DEV_INTERFACE));
   if (NULL == fileio_interface_) {
     *error = "Failed to get browser interface '" PPB_FILEIO_DEV_INTERFACE;
     return false;
   }
   fileio_ = fileio_interface_->Create(module->module_id());
   if (0 == fileio_) {
     *error = "PPB_FileIO_Dev::Create: failed";
@@ skipping 37 matching lines @@
     ReportFailure("UrlLoadRequest::OpenCallback: ", pp_error);
     return;
   }
 
   // Validating response headers to confirm successful loading.
   response_ = loader_interface_->GetResponseInfo(loader_);
   if (0 == response_) {
     ReportFailure("UrlLoadRequest::OpenCallback: null response");
     return;
   }
+  TestIsInterface(PPB_URLRESPONSEINFO_INTERFACE, response_,
+                  request_interface_, response_interface_, loader_interface_);
   PP_Var url = response_interface_->GetProperty(response_,
                                                 PP_URLRESPONSEPROPERTY_URL);
   if (url.type != PP_VARTYPE_STRING) {
     ReportFailure("URLLoadRequest::OpenCallback: bad url type");
     return;
   }
   url_ = Module::VarToStr(url);  // Update url to be fully qualified.
   PP_Var status_code =
       response_interface_->GetProperty(response_,
                                        PP_URLRESPONSEPROPERTY_STATUSCODE);
@@ skipping 23 matching lines @@
   printf("--- UrlLoadRequest::FinishStreamingToFileCallback\n");
   if (pp_error != PP_OK) {
     ReportFailure("UrlLoadRequest::FinishStreamingToFileCallback: ", pp_error);
     return;
   }
   PP_Resource fileref = response_interface_->GetBodyAsFileRef(response_);
   if (0 == fileref) {
     ReportFailure("UrlLoadRequest::FinishStreamingToFileCallback: null file");
     return;
   }
+// TODO(sanga): enable this for untrusted code when FileIO proxy is supported.
+#if !defined(__native_client__)
   pp_error = fileio_interface_->Open(
       fileio_,
       fileref,
       PP_FILEOPENFLAG_READ,
       PP_MakeCompletionCallback(::OpenFileBodyCallback, this));
   CHECK(pp_error != PP_OK);  // Open() never succeeds synchronously.
   if (pp_error != PP_ERROR_WOULDBLOCK)  {  // Async failure.
     ReportFailure("PPB_FileIO::Open: ", pp_error);
   }
+#else
+  ReportFailure("PPB_FileIO not supported");
+#endif
 }
 
 void UrlLoadRequest::ReadResponseBodyCallback(int32_t pp_error_or_bytes) {
   printf("--- UrlLoadRequest::ReadResponseBodyCallback\n");
   if (pp_error_or_bytes < PP_OK) {
     ReportFailure("UrlLoadRequest::ReadResponseBodyCallback: ",
                   pp_error_or_bytes);
   } else if (pp_error_or_bytes == PP_OK) {  // Reached EOF.
     ReportSuccess();
   } else {  // Partial read, so copy out the buffer and continue reading.
@@ skipping 19 matching lines @@
 }
 
 void UrlLoadRequest::OpenFileBodyCallback(int32_t pp_error) {
   printf("--- UrlLoadRequest::OpenFileBodyCallback\n");
   if (pp_error != PP_OK) {
     ReportFailure("UrlLoadRequest::OpenFileBodyCallback: ", pp_error);
     return;
   }
   ReadFileBody();
 }