[NaCl SDK] Implement FakePepperInterfaceGoogleDriveFs

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

Index: native_client_sdk/src/tests/nacl_io_test/fake_ppapi/fake_pepper_interface_googledrivefs.cc
diff --git a/native_client_sdk/src/tests/nacl_io_test/fake_ppapi/fake_pepper_interface_googledrivefs.cc b/native_client_sdk/src/tests/nacl_io_test/fake_ppapi/fake_pepper_interface_googledrivefs.cc
new file mode 100644
index 0000000000000000000000000000000000000000..d0a14a39d132c4b01b6640acf791ab5398c62586
--- /dev/null
+++ b/native_client_sdk/src/tests/nacl_io_test/fake_ppapi/fake_pepper_interface_googledrivefs.cc
@@ -0,0 +1,312 @@
+// Copyright 2016 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_googledrivefs.h"
+
+#include <ppapi/c/pp_completion_callback.h>
+#include <ppapi/c/pp_errors.h>
+
+#include "gtest/gtest.h"
+
+#include "fake_ppapi/fake_core_interface.h"
+#include "fake_ppapi/fake_file_ref_interface.h"
+#include "fake_ppapi/fake_pepper_interface_url_loader.h"
+#include "fake_ppapi/fake_util.h"
+#include "fake_ppapi/fake_var_interface.h"
+
+class FakeDriveInstanceResource : public FakeResource {
+ public:
+  FakeDriveInstanceResource() : server_template(NULL) {}
+  static const char* classname() { return "FakeDriveInstanceResource"; }
+
+  FakeGoogleDriveServer* server_template;
+};
+
+class FakeDriveURLLoaderResource : public FakeResource {
+ public:
+  FakeDriveURLLoaderResource() : manager(NULL), server(NULL), response(0) {}
+
+  virtual void Destroy() {
+    EXPECT_TRUE(manager != NULL);
+    if (response != 0)
+      manager->Release(response);
+  }
+
+  static const char* classname() { return "FakeDriveURLLoaderResource"; }
+
+  FakeResourceManager* manager;
+  FakeGoogleDriveServer* server;
+  PP_Resource response;
+  std::string response_body;
+};
+
+class FakeDriveResponseResource : public FakeURLResponseInfoResource {
+ public:
+  FakeDriveResponseResource()
+      : manager(NULL), loader(0), file_ref(0), stream_to_file(false) {}
+
+  virtual void Destroy() {
+    EXPECT_TRUE(manager != NULL);
+    if (loader != 0)
+      manager->Release(loader);
+
+    if (file_ref != 0)
+      manager->Release(file_ref);
+  }
+
+  static const char* classname() { return "FakeDriveResponseResource"; }
+
+  FakeResourceManager* manager;
+  PP_Resource loader;
+  PP_Resource file_ref;
+  bool stream_to_file;
+  std::string body;
+};
+
+FakeGoogleDriveServer::FakeGoogleDriveServer() {}
+
+void FakeGoogleDriveServer::Respond(
+    const std::string& url,
+    const std::string& headers,
+    const std::string& method,
+    const std::string& body,
+    FakeGoogleDriveServerResponse* out_response) {
+  out_response->status_code = STATUSCODE_NOT_IMPLEMENTED;
+}
+
+FakeDriveURLLoaderInterface::FakeDriveURLLoaderInterface(
+    FakeCoreInterface* core_interface)
+    : FakeURLLoaderInterface(core_interface) {}
+
+PP_Resource FakeDriveURLLoaderInterface::Create(PP_Instance instance) {
+  FakeDriveInstanceResource* drive_instance_resource =
+      core_interface_->resource_manager()->Get<FakeDriveInstanceResource>(
+          instance);
+  if (drive_instance_resource == NULL)
+    return 0;
+
+  FakeDriveURLLoaderResource* drive_loader_resource =
+      new FakeDriveURLLoaderResource;
+  drive_loader_resource->manager = core_interface_->resource_manager();
+  drive_loader_resource->server = drive_instance_resource->server_template;
+
+  return CREATE_RESOURCE(core_interface_->resource_manager(),
+                         FakeDriveURLLoaderResource, drive_loader_resource);
+}
+
+int32_t FakeDriveURLLoaderInterface::Open(PP_Resource loader,
+                                          PP_Resource request,
+                                          PP_CompletionCallback callback) {
+  FakeDriveURLLoaderResource* drive_loader_resource =
+      core_interface_->resource_manager()->Get<FakeDriveURLLoaderResource>(
+          loader);
+  if (drive_loader_resource == NULL)
+    return PP_ERROR_BADRESOURCE;
+
+  // Close() has been called. Invalid to call Open() again.
+  if (drive_loader_resource->server == NULL)
+    return PP_ERROR_FAILED;
+
+  FakeURLRequestInfoResource* request_resource =
+      core_interface_->resource_manager()->Get<FakeURLRequestInfoResource>(
+          request);
+  if (request_resource == NULL)
+    return PP_ERROR_BADRESOURCE;
+
+  // Create a response resource.
+  FakeDriveResponseResource* drive_response_resource =
+      new FakeDriveResponseResource;
+  drive_response_resource->manager = drive_loader_resource->manager;
+  drive_loader_resource->response =
+      CREATE_RESOURCE(core_interface_->resource_manager(),
+                      FakeDriveResponseResource, drive_response_resource);
+
+  drive_response_resource->loader = loader;
+  core_interface_->resource_manager()->AddRef(drive_response_resource->loader);
+
+  drive_response_resource->stream_to_file = request_resource->stream_to_file;
+
+  FakeGoogleDriveServerResponse server_response;
+  drive_loader_resource->server->Respond(
+      request_resource->url, request_resource->headers,
+      request_resource->method, request_resource->body, &server_response);
+
+  drive_response_resource->status_code = server_response.status_code;
+  drive_loader_resource->response_body = server_response.body;
+
+  // Call the callback.
+  return RunCompletionCallback(&callback, PP_OK);
+}
+
+PP_Resource FakeDriveURLLoaderInterface::GetResponseInfo(PP_Resource loader) {
+  FakeDriveURLLoaderResource* drive_loader_resource =
+      core_interface_->resource_manager()->Get<FakeDriveURLLoaderResource>(
+          loader);
+  if (drive_loader_resource == NULL)
+    return 0;
+
+  if (drive_loader_resource->response == 0)
+    return 0;
+
+  // Returned resources have an implicit AddRef.
+  core_interface_->resource_manager()->AddRef(drive_loader_resource->response);
+  return drive_loader_resource->response;
+}
+
+int32_t FakeDriveURLLoaderInterface::FinishStreamingToFile(
+    PP_Resource loader,
+    PP_CompletionCallback callback) {
+  FakeDriveURLLoaderResource* drive_loader_resource =
+      core_interface_->resource_manager()->Get<FakeDriveURLLoaderResource>(
+          loader);
+  if (drive_loader_resource == NULL)
+    return PP_ERROR_BADRESOURCE;
+
+  FakeDriveResponseResource* drive_response_resource =
+      core_interface_->resource_manager()->Get<FakeDriveResponseResource>(
+          drive_loader_resource->response);
+  if (drive_response_resource == NULL)
+    return PP_ERROR_BADRESOURCE;
+
+  if (!drive_response_resource->stream_to_file)
+    return PP_ERROR_FAILED;
+
+  drive_response_resource->body = drive_loader_resource->response_body;
+
+  // PPB_URLLoader::FinishStreamingToFile(..) returns 0 even when
+  // the response body size is > 0.
+  return 0;
+}
+
+void FakeDriveURLLoaderInterface::Close(PP_Resource loader) {
+  FakeDriveURLLoaderResource* drive_loader_resource =
+      core_interface_->resource_manager()->Get<FakeDriveURLLoaderResource>(
+          loader);
+  if (drive_loader_resource == NULL)
+    return;
+
+  core_interface_->resource_manager()->Release(drive_loader_resource->response);
+
+  drive_loader_resource->server = NULL;
+  drive_loader_resource->response = 0;
+  drive_loader_resource->response_body.clear();
+}
+
+FakeDriveURLResponseInfoInterface::FakeDriveURLResponseInfoInterface(
+    FakeCoreInterface* core_interface,
+    FakeVarInterface* var_interface,
+    FakeFileRefInterface* file_ref_interface)
+    : FakeURLResponseInfoInterface(core_interface, var_interface),
+      file_ref_interface_(file_ref_interface) {
+  FakeFileSystemResource* file_system_resource = new FakeFileSystemResource;
+  file_system_resource->filesystem = new FakeFilesystem();
+  file_system_resource->opened = true;
+
+  filesystem_resource_ =
+      CREATE_RESOURCE(core_interface_->resource_manager(),
+                      FakeFileSystemResource, file_system_resource);
+}
+
+FakeDriveURLResponseInfoInterface::~FakeDriveURLResponseInfoInterface() {
+  core_interface_->ReleaseResource(filesystem_resource_);
+}
+
+PP_Resource FakeDriveURLResponseInfoInterface::GetBodyAsFileRef(
+    PP_Resource response) {
+  FakeDriveResponseResource* drive_response_resource =
+      core_interface_->resource_manager()->Get<FakeDriveResponseResource>(
+          response);
+  if (drive_response_resource == NULL)
+    return 0;
+
+  if (!drive_response_resource->stream_to_file)
+    return 0;
+
+  FakeDriveURLLoaderResource* drive_loader_resource =
+      core_interface_->resource_manager()->Get<FakeDriveURLLoaderResource>(
+          drive_response_resource->loader);
+  if (drive_loader_resource == NULL)
+    return 0;
+
+  if (drive_loader_resource->server == NULL)
+    return 0;
+
+  if (drive_response_resource->file_ref == 0) {
+    FakeFileSystemResource* file_system_resource =
+        core_interface_->resource_manager()->Get<FakeFileSystemResource>(
+            filesystem_resource_);
+    if (file_system_resource == NULL)
+      return 0;
+
+    char path_buffer[32];
+    snprintf(path_buffer, sizeof(path_buffer), "%u", response);
+
+    FakeNode* fake_node;
+    if (!file_system_resource->filesystem->AddFile(
+            path_buffer, drive_response_resource->body, &fake_node))
+      return 0;
+
+    drive_response_resource->file_ref =
+        file_ref_interface_->Create(filesystem_resource_, path_buffer);
+  }
+
+  // Returned resources have an implicit AddRef.
+  core_interface_->resource_manager()->AddRef(
+      drive_response_resource->file_ref);
+  return drive_response_resource->file_ref;
+}
+
+FakePepperInterfaceGoogleDriveFs::FakePepperInterfaceGoogleDriveFs()
+    : core_interface_(&resource_manager_),
+      var_interface_(&var_manager_),
+      file_ref_interface_(&core_interface_, &var_interface_),
+      drive_url_loader_interface_(&core_interface_),
+      url_request_info_interface_(&core_interface_, &var_interface_),
+      drive_url_response_info_interface_(&core_interface_,
+                                         &var_interface_,
+                                         &file_ref_interface_) {
+  Init();
+}
+
+void FakePepperInterfaceGoogleDriveFs::Init() {
+  FakeDriveInstanceResource* drive_instance_resource =
+      new FakeDriveInstanceResource;
+  drive_instance_resource->server_template = &google_drive_server_template_;
+
+  instance_ =
+      CREATE_RESOURCE(core_interface_.resource_manager(),
+                      FakeDriveInstanceResource, drive_instance_resource);
+}
+
+FakePepperInterfaceGoogleDriveFs::~FakePepperInterfaceGoogleDriveFs() {
+  core_interface_.ReleaseResource(instance_);
+}
+
+nacl_io::CoreInterface* FakePepperInterfaceGoogleDriveFs::GetCoreInterface() {
+  return &core_interface_;
+}
+
+nacl_io::FileRefInterface*
+FakePepperInterfaceGoogleDriveFs::GetFileRefInterface() {
+  return &file_ref_interface_;
+}
+
+nacl_io::URLLoaderInterface*
+FakePepperInterfaceGoogleDriveFs::GetURLLoaderInterface() {
+  return &drive_url_loader_interface_;
+}
+
+nacl_io::URLRequestInfoInterface*
+FakePepperInterfaceGoogleDriveFs::GetURLRequestInfoInterface() {
+  return &url_request_info_interface_;
+}
+
+nacl_io::URLResponseInfoInterface*
+FakePepperInterfaceGoogleDriveFs::GetURLResponseInfoInterface() {
+  return &drive_url_response_info_interface_;
+}
+
+nacl_io::VarInterface* FakePepperInterfaceGoogleDriveFs::GetVarInterface() {
+  return &var_interface_;
+}