[NaCl SDK] Expose Google Drive to nacl_io.

native_client_sdk/src/tests/nacl_io_test/fake_ppapi/fake_pepper_interface_url_loader.cc

 // Copyright 2014 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 "fake_ppapi/fake_pepper_interface_url_loader.h"
 
 #include <string.h>
 #include <strings.h>
 
 #include <algorithm>
 #include <sstream>
 
 #include "gtest/gtest.h"
 
 #include "nacl_io/osinttypes.h"
 
+#include "fake_ppapi/fake_filesystem.h"
+#include "fake_ppapi/fake_util.h"
+
 namespace {
 
 bool GetHeaderValue(const std::string& headers,
                     const std::string& key,
                     std::string* out_value) {
   out_value->clear();
 
   size_t offset = 0;
   while (offset != std::string::npos) {
     // Find the next colon; this separates the key from the value.
@@ skipping 42 matching lines @@
     EXPECT_TRUE(manager != NULL);
     if (response != 0)
       manager->Release(response);
     delete server;
   }
 
   static const char* classname() { return "FakeURLLoaderResource"; }
 
   FakeResourceManager* manager;  // Weak reference.
   FakeURLLoaderServer* server;
-  FakeURLLoaderEntity* entity;   // Weak reference.
+  FakeURLLoaderEntity* entity;  // Weak reference.
   PP_Resource response;
   off_t read_offset;
   off_t read_end;
 };
 
-class FakeURLRequestInfoResource : public FakeResource {
- public:
-  FakeURLRequestInfoResource() {}
-  static const char* classname() { return "FakeURLRequestInfoResource"; }
-
-  std::string url;
-  std::string method;
-  std::string headers;
-};
-
-class FakeURLResponseInfoResource : public FakeResource {
- public:
-  FakeURLResponseInfoResource() : status_code(0) {}
-  static const char* classname() { return "FakeURLResponseInfoResource"; }
-
-  int status_code;
-  std::string url;
-  std::string headers;
-};
-
-// Helper function to call the completion callback if it is defined (an
-// asynchronous call), or return the result directly if it isn't (a synchronous
-// call).
-//
-// Use like this:
-//   if (<some error condition>)
-//     return RunCompletionCallback(callback, PP_ERROR_FUBAR);
-//
-//   /* Everything worked OK */
-//   return RunCompletionCallback(callback, PP_OK);
-int32_t RunCompletionCallback(PP_CompletionCallback* callback, int32_t result) {
-  if (callback->func) {
-    PP_RunCompletionCallback(callback, result);
-    return PP_OK_COMPLETIONPENDING;
-  }
-  return result;
-}
-
 void HandleContentLength(FakeURLLoaderResource* loader,
                          FakeURLResponseInfoResource* response,
                          FakeURLLoaderEntity* entity) {
   off_t content_length = entity->size();
   if (!loader->server->send_content_length())
     return;
 
   std::ostringstream ss;
   ss << "Content-Length: " << content_length << "\n";
   response->headers += ss.str();
@@ skipping 14 matching lines @@
 
   // We don't support all range requests, just bytes=<num>-<num>
   off_t lo;
   off_t hi;
   if (sscanf(range.c_str(), "bytes=%" SCNi64 "-%" SCNi64, &lo, &hi) != 2) {
     // Couldn't parse the range value.
     return;
   }
 
   off_t content_length = entity->size();
-  if (lo > content_length) {
+  if (lo >= content_length) {
     // Trying to start reading past the end of the entity is
     // unsatisfiable.
     response->status_code = 416;  // Request range not satisfiable.
     return;
   }
 
   // Clamp the hi value to the content length.
   if (hi >= content_length)
     hi = content_length - 1;
 
@@ skipping 13 matching lines @@
   ss << "Content-Range: bytes " << lo << "-" << hi << "/" << content_length
      << "\n";
   response->headers += ss.str();
 
   response->status_code = 206;  // Partial content
 }
 
 }  // namespace
 
 FakeURLLoaderEntity::FakeURLLoaderEntity(const std::string& body)
-    : body_(body), size_(body_.size()), repeat_(false) {
-}
+    : body_(body), size_(body_.size()), repeat_(false) {}
 
 // Rather than specifying the entire file, specify a string to repeat, and the
 // full length. This lets us test extremely large files without having to store
 // them in memory.
 FakeURLLoaderEntity::FakeURLLoaderEntity(const std::string& to_repeat,
                                          off_t size)
-    : body_(to_repeat), size_(size), repeat_(true) {
-}
+    : body_(to_repeat), size_(size), repeat_(true) {}
 
 size_t FakeURLLoaderEntity::Read(void* buffer, size_t count, off_t offset) {
   off_t max_read_count =
       std::max<off_t>(std::min<off_t>(size_ - offset, 0xffffffff), 0);
   size_t bytes_to_read = std::min(count, static_cast<size_t>(max_read_count));
 
   if (repeat_) {
     size_t src_size = body_.size();
     char* dst = static_cast<char*>(buffer);
     const char* src = body_.data();
@@ skipping 24 matching lines @@
     memcpy(buffer, &body_.data()[offset], bytes_to_read);
   }
 
   return bytes_to_read;
 }
 
 FakeURLLoaderServer::FakeURLLoaderServer()
     : max_read_size_(0),
       send_content_length_(false),
       allow_partial_(false),
-      allow_head_(true) {
-}
+      allow_head_(true) {}
 
 void FakeURLLoaderServer::Clear() {
   entity_map_.clear();
 }
 
 bool FakeURLLoaderServer::AddEntity(const std::string& url,
                                     const std::string& body,
                                     FakeURLLoaderEntity** out_entity) {
   EntityMap::iterator iter = entity_map_.find(url);
   if (iter != entity_map_.end()) {
@@ skipping 60 matching lines @@
 
 int FakeURLLoaderServer::GetError(const std::string& url) {
   ErrorMap::iterator iter = error_map_.find(url);
   if (iter == error_map_.end())
     return 0;
   return iter->second;
 }
 
 FakeURLLoaderInterface::FakeURLLoaderInterface(
     FakeCoreInterface* core_interface)
-    : core_interface_(core_interface) {
-}
+    : core_interface_(core_interface) {}
 
 PP_Resource FakeURLLoaderInterface::Create(PP_Instance instance) {
   FakeInstanceResource* instance_resource =
       core_interface_->resource_manager()->Get<FakeInstanceResource>(instance);
   if (instance_resource == NULL)
     return PP_ERROR_BADRESOURCE;
 
   FakeURLLoaderResource* loader_resource = new FakeURLLoaderResource;
   loader_resource->manager = core_interface_->resource_manager();
   loader_resource->server =
       new FakeURLLoaderServer(*instance_resource->server_template);
 
   return CREATE_RESOURCE(core_interface_->resource_manager(),
-                         FakeURLLoaderResource,
-                         loader_resource);
+                         FakeURLLoaderResource, loader_resource);
 }
 
 int32_t FakeURLLoaderInterface::Open(PP_Resource loader,
                                      PP_Resource request,
                                      PP_CompletionCallback callback) {
   FakeURLLoaderResource* loader_resource =
       core_interface_->resource_manager()->Get<FakeURLLoaderResource>(loader);
   if (loader_resource == NULL)
     return PP_ERROR_BADRESOURCE;
 
   FakeURLRequestInfoResource* request_resource =
       core_interface_->resource_manager()->Get<FakeURLRequestInfoResource>(
           request);
   if (request_resource == NULL)
     return PP_ERROR_BADRESOURCE;
 
   // Create a response resource.
   FakeURLResponseInfoResource* response_resource =
       new FakeURLResponseInfoResource;
   loader_resource->response =
       CREATE_RESOURCE(core_interface_->resource_manager(),
-                      FakeURLResponseInfoResource,
-                      response_resource);
+                      FakeURLResponseInfoResource, response_resource);
 
   loader_resource->entity = NULL;
   loader_resource->read_offset = 0;
   loader_resource->read_end = 0;
 
   // Get the URL from the request info.
   std::string url = request_resource->url;
   std::string method = request_resource->method;
 
   response_resource->url = url;
@@ skipping 63 matching lines @@
   if (server_max_read_size != 0)
     bytes_to_read = std::min<int32_t>(bytes_to_read, server_max_read_size);
 
   size_t bytes_read = loader_resource->entity->Read(
       buffer, bytes_to_read, loader_resource->read_offset);
   loader_resource->read_offset += bytes_read;
 
   return RunCompletionCallback(&callback, bytes_read);
 }
 
+int32_t FakeURLLoaderInterface::FinishStreamingToFile(
+    PP_Resource loader,
+    PP_CompletionCallback callback) {
+  return PP_ERROR_NOTSUPPORTED;
+}
+
 void FakeURLLoaderInterface::Close(PP_Resource loader) {
   FakeURLLoaderResource* loader_resource =
       core_interface_->resource_manager()->Get<FakeURLLoaderResource>(loader);
   if (loader_resource == NULL)
     return;
 
   core_interface_->resource_manager()->Release(loader_resource->response);
 
   loader_resource->server = NULL;
   loader_resource->entity = NULL;
   loader_resource->response = 0;
   loader_resource->read_offset = 0;
 }
 
 FakeURLRequestInfoInterface::FakeURLRequestInfoInterface(
     FakeCoreInterface* core_interface,
     FakeVarInterface* var_interface)
-    : core_interface_(core_interface), var_interface_(var_interface) {
-}
+    : core_interface_(core_interface), var_interface_(var_interface) {}
 
 PP_Resource FakeURLRequestInfoInterface::Create(PP_Instance instance) {
-  FakeInstanceResource* instance_resource =
-      core_interface_->resource_manager()->Get<FakeInstanceResource>(instance);
-  if (instance_resource == NULL)
-    return PP_ERROR_BADRESOURCE;
-
   return CREATE_RESOURCE(core_interface_->resource_manager(),
                          FakeURLRequestInfoResource,
                          new FakeURLRequestInfoResource);
 }
 
 PP_Bool FakeURLRequestInfoInterface::SetProperty(PP_Resource request,
                                                  PP_URLRequestProperty property,
                                                  PP_Var value) {
   FakeURLRequestInfoResource* request_resource =
       core_interface_->resource_manager()->Get<FakeURLRequestInfoResource>(
@@ skipping 46 matching lines @@
         return PP_FALSE;
       // Throw the value away for now. TODO(binji): add tests for this.
       return PP_TRUE;
     }
     case PP_URLREQUESTPROPERTY_ALLOWCREDENTIALS: {
       if (value.type != PP_VARTYPE_BOOL)
         return PP_FALSE;
       // Throw the value away for now. TODO(binji): add tests for this.
       return PP_TRUE;
     }
+    case PP_URLREQUESTPROPERTY_STREAMTOFILE: {
+      if (value.type != PP_VARTYPE_BOOL)
+        return PP_FALSE;
+      // Throw the value away for now. TODO: add tests for this.

[chanpatorikku, 2016/08/07 02:41:03]

Another TODO, FYI.

+      return PP_TRUE;
+    }
     default:
       EXPECT_TRUE(false) << "Unimplemented property " << property
                          << " in "
                             "FakeURLRequestInfoInterface::SetProperty";
       return PP_FALSE;
   }
 }
 
+PP_Bool FakeURLRequestInfoInterface::AppendDataToBody(PP_Resource request,
+                                                      const void* data,
+                                                      uint32_t len) {
+  FakeURLRequestInfoResource* request_resource =
+      core_interface_->resource_manager()->Get<FakeURLRequestInfoResource>(
+          request);
+  if (request_resource == NULL)
+    return PP_FALSE;
+
+  request_resource->body = std::string((char*)data, len);
+
+  return PP_TRUE;
+}
+
 FakeURLResponseInfoInterface::FakeURLResponseInfoInterface(
     FakeCoreInterface* core_interface,
-    FakeVarInterface* var_interface)
-    : core_interface_(core_interface), var_interface_(var_interface) {
+    FakeVarInterface* var_interface,
+    FakeFileRefInterface* file_ref_interface)
+    : core_interface_(core_interface),
+      var_interface_(var_interface),
+      file_ref_interface_(file_ref_interface) {
+  FakeFileSystemResource* file_system_resource = new FakeFileSystemResource;
+  file_system_resource->filesystem = new FakeFilesystem();
+
+  filesystem_resource_ =
+      CREATE_RESOURCE(core_interface_->resource_manager(),
+                      FakeFileSystemResource, file_system_resource);
+}
+
+FakeURLResponseInfoInterface::~FakeURLResponseInfoInterface() {
+  core_interface_->ReleaseResource(filesystem_resource_);
 }
 
 PP_Var FakeURLResponseInfoInterface::GetProperty(
     PP_Resource response,
     PP_URLResponseProperty property) {
   FakeURLResponseInfoResource* response_resource =
       core_interface_->resource_manager()->Get<FakeURLResponseInfoResource>(
           response);
   if (response_resource == NULL)
     return PP_Var();
@@ skipping 10 matching lines @@
       return var_interface_->VarFromUtf8(response_resource->headers.data(),
                                          response_resource->headers.size());
     default:
       EXPECT_TRUE(false) << "Unimplemented property " << property
                          << " in "
                             "FakeURLResponseInfoInterface::GetProperty";
       return PP_Var();
   }
 }
 
+PP_Resource FakeURLResponseInfoInterface::GetBodyAsFileRef(
+    PP_Resource response) {
+  FakeURLResponseInfoResource* response_resource =
+      core_interface_->resource_manager()->Get<FakeURLResponseInfoResource>(
+          response);
+  if (response_resource == NULL)
+    return PP_ERROR_BADRESOURCE;
+
+  FakeFileSystemResource* file_system_resource =
+      core_interface_->resource_manager()->Get<FakeFileSystemResource>(
+          filesystem_resource_);
+
+  if (file_system_resource == NULL)
+    return PP_ERROR_BADRESOURCE;
+
+  char path_buffer[1024];
+  int char_written = sprintf(path_buffer, "%i", response);
+  if (char_written < 0) {
+    return PP_ERROR_FAILED;
+  }
+
+  FakeNode* fake_node;
+  if (!file_system_resource->filesystem->AddFile(
+          std::string(path_buffer), response_resource->body, &fake_node)) {
+    return PP_ERROR_FAILED;
+  }
+
+  file_system_resource->opened = true;
+
+  return file_ref_interface_->Create(filesystem_resource_, path_buffer);
+}
+
 FakePepperInterfaceURLLoader::FakePepperInterfaceURLLoader()
     : core_interface_(&resource_manager_),
       var_interface_(&var_manager_),
+      file_ref_interface_(&core_interface_, &var_interface_),
       url_loader_interface_(&core_interface_),
       url_request_info_interface_(&core_interface_, &var_interface_),
-      url_response_info_interface_(&core_interface_, &var_interface_) {
+      url_response_info_interface_(&core_interface_,
+                                   &var_interface_,
+                                   &file_ref_interface_) {
   FakeInstanceResource* instance_resource = new FakeInstanceResource;
   instance_resource->server_template = &server_template_;
   instance_ = CREATE_RESOURCE(core_interface_.resource_manager(),
-                              FakeInstanceResource,
-                              instance_resource);
+                              FakeInstanceResource, instance_resource);
 }
 
 FakePepperInterfaceURLLoader::~FakePepperInterfaceURLLoader() {
   core_interface_.ReleaseResource(instance_);
 }
 
 nacl_io::CoreInterface* FakePepperInterfaceURLLoader::GetCoreInterface() {
   return &core_interface_;
 }
 
 nacl_io::VarInterface* FakePepperInterfaceURLLoader::GetVarInterface() {
   return &var_interface_;
 }
 
+nacl_io::FileRefInterface* FakePepperInterfaceURLLoader::GetFileRefInterface() {
+  return &file_ref_interface_;
+}
+
 nacl_io::URLLoaderInterface*
 FakePepperInterfaceURLLoader::GetURLLoaderInterface() {
   return &url_loader_interface_;
 }
 
 nacl_io::URLRequestInfoInterface*
 FakePepperInterfaceURLLoader::GetURLRequestInfoInterface() {
   return &url_request_info_interface_;
 }
 
 nacl_io::URLResponseInfoInterface*
 FakePepperInterfaceURLLoader::GetURLResponseInfoInterface() {
   return &url_response_info_interface_;
 }