chromeos: Add VirtualFileProvider D-Bus client

BUG=740063
TEST=build

Change-Id: Idbb52590a586dbc55bba52979eec8a2790d8ac60
Reviewed-on: https://chromium-review.googlesource.com/593427Reviewed-by: Satoru Takabayashi <satorux@chromium.org>
Commit-Queue: Ryo Hashimoto <hashimoto@chromium.org>
Cr-Commit-Position: refs/heads/master@{#501546}

chromeos/BUILD.gn

@@ -215,6 +215,8 @@ component("chromeos") {
     "dbus/fake_system_clock_client.h",
     "dbus/fake_upstart_client.cc",
     "dbus/fake_upstart_client.h",
+    "dbus/fake_virtual_file_provider_client.cc",
+    "dbus/fake_virtual_file_provider_client.h",
     "dbus/gsm_sms_client.cc",
     "dbus/gsm_sms_client.h",
     "dbus/image_burner_client.cc",
@@ -269,6 +271,8 @@ component("chromeos") {
     "dbus/update_engine_client.h",
     "dbus/upstart_client.cc",
     "dbus/upstart_client.h",
+    "dbus/virtual_file_provider_client.cc",
+    "dbus/virtual_file_provider_client.h",
     "dbus/volume_state.cc",
     "dbus/volume_state.h",
     "disks/disk_mount_manager.cc",

chromeos/dbus/dbus_clients_browser.cc

@@ -25,11 +25,13 @@
 #include "chromeos/dbus/fake_lorgnette_manager_client.h"
 #include "chromeos/dbus/fake_media_analytics_client.h"
 #include "chromeos/dbus/fake_upstart_client.h"
+#include "chromeos/dbus/fake_virtual_file_provider_client.h"
 #include "chromeos/dbus/image_burner_client.h"
 #include "chromeos/dbus/image_loader_client.h"
 #include "chromeos/dbus/lorgnette_manager_client.h"
 #include "chromeos/dbus/media_analytics_client.h"
 #include "chromeos/dbus/upstart_client.h"
+#include "chromeos/dbus/virtual_file_provider_client.h"
 
 namespace chromeos {
 
@@ -92,6 +94,11 @@ DBusClientsBrowser::DBusClientsBrowser(bool use_real_clients) {
     upstart_client_.reset(UpstartClient::Create());
   else
     upstart_client_.reset(new FakeUpstartClient);
+
+  if (use_real_clients)
+    virtual_file_provider_client_.reset(VirtualFileProviderClient::Create());
+  else
+    virtual_file_provider_client_.reset(new FakeVirtualFileProviderClient);
 }
 
 DBusClientsBrowser::~DBusClientsBrowser() {}
@@ -111,6 +118,7 @@ void DBusClientsBrowser::Initialize(dbus::Bus* system_bus) {
   lorgnette_manager_client_->Init(system_bus);
   media_analytics_client_->Init(system_bus);
   upstart_client_->Init(system_bus);
+  virtual_file_provider_client_->Init(system_bus);
 }
 
 }  // namespace chromeos

chromeos/dbus/dbus_clients_browser.h

@@ -28,6 +28,7 @@ class ImageLoaderClient;
 class LorgnetteManagerClient;
 class MediaAnalyticsClient;
 class UpstartClient;
+class VirtualFileProviderClient;
 
 // D-Bus clients used only in the browser process.
 // TODO(jamescook): Move this under //chrome/browser. http://crbug.com/647367
@@ -56,6 +57,7 @@ class CHROMEOS_EXPORT DBusClientsBrowser {
   std::unique_ptr<LorgnetteManagerClient> lorgnette_manager_client_;
   std::unique_ptr<MediaAnalyticsClient> media_analytics_client_;
   std::unique_ptr<UpstartClient> upstart_client_;
+  std::unique_ptr<VirtualFileProviderClient> virtual_file_provider_client_;
 
   DISALLOW_COPY_AND_ASSIGN(DBusClientsBrowser);
 };

chromeos/dbus/dbus_thread_manager.cc

@@ -239,6 +239,12 @@ UpstartClient* DBusThreadManager::GetUpstartClient() {
   return clients_browser_ ? clients_browser_->upstart_client_.get() : nullptr;
 }
 
+VirtualFileProviderClient* DBusThreadManager::GetVirtualFileProviderClient() {
+  return clients_browser_
+             ? clients_browser_->virtual_file_provider_client_.get()
+             : nullptr;
+}
+
 void DBusThreadManager::InitializeClients() {
   // Some clients call DBusThreadManager::Get() during initialization.
   DCHECK(g_dbus_thread_manager);

chromeos/dbus/dbus_thread_manager.h

@@ -56,6 +56,7 @@ class ShillThirdPartyVpnDriverClient;
 class SystemClockClient;
 class UpdateEngineClient;
 class UpstartClient;
+class VirtualFileProviderClient;
 
 // DBusThreadManager manages the D-Bus thread, the thread dedicated to
 // handling asynchronous D-Bus operations.
@@ -151,6 +152,7 @@ class CHROMEOS_EXPORT DBusThreadManager {
   SystemClockClient* GetSystemClockClient();
   UpdateEngineClient* GetUpdateEngineClient();
   UpstartClient* GetUpstartClient();
+  VirtualFileProviderClient* GetVirtualFileProviderClient();
 
  private:
   friend class DBusThreadManagerSetter;

chromeos/dbus/fake_virtual_file_provider_client.cc

+// Copyright 2017 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 "chromeos/dbus/fake_virtual_file_provider_client.h"
+
+#include "base/callback.h"
+
+namespace chromeos {
+
+FakeVirtualFileProviderClient::FakeVirtualFileProviderClient() = default;
+FakeVirtualFileProviderClient::~FakeVirtualFileProviderClient() = default;
+
+void FakeVirtualFileProviderClient::Init(dbus::Bus* bus) {}
+
+void FakeVirtualFileProviderClient::OpenFile(int64_t size,
+                                             OpenFileCallback callback) {}
+
+}  // namespace chromeos

chromeos/dbus/fake_virtual_file_provider_client.h

+// Copyright 2017 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.
+
+#ifndef CHROMEOS_DBUS_FAKE_VIRTUAL_FILE_PROVIDER_CLIENT_H_
+#define CHROMEOS_DBUS_FAKE_VIRTUAL_FILE_PROVIDER_CLIENT_H_
+
+#include "chromeos/dbus/virtual_file_provider_client.h"
+
+namespace chromeos {
+
+class CHROMEOS_EXPORT FakeVirtualFileProviderClient
+    : public VirtualFileProviderClient {
+ public:
+  FakeVirtualFileProviderClient();
+  ~FakeVirtualFileProviderClient() override;
+
+  // DBusClient override.
+  void Init(dbus::Bus* bus) override;
+
+  // VirtualFileProviderClient overrides:
+  void OpenFile(int64_t size, OpenFileCallback callback) override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(FakeVirtualFileProviderClient);
+};
+
+}  // namespace chromeos
+
+#endif  // CHROMEOS_DBUS_FAKE_VIRTUAL_FILE_PROVIDER_CLIENT_H_

chromeos/dbus/virtual_file_provider_client.cc

+// Copyright 2017 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 "chromeos/dbus/virtual_file_provider_client.h"
+
+#include <utility>
+
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/callback.h"
+#include "dbus/bus.h"
+#include "dbus/message.h"
+#include "dbus/object_proxy.h"
+#include "third_party/cros_system_api/dbus/service_constants.h"
+
+namespace chromeos {
+
+namespace {
+
+class VirtualFileProviderClientImpl : public VirtualFileProviderClient {
+ public:
+  VirtualFileProviderClientImpl() : weak_ptr_factory_(this) {}
+  ~VirtualFileProviderClientImpl() override = default;
+
+  // VirtualFileProviderClient override:
+  void OpenFile(int64_t size, OpenFileCallback callback) override {
+    dbus::MethodCall method_call(
+        virtual_file_provider::kVirtualFileProviderInterface,
+        virtual_file_provider::kOpenFileMethod);
+    dbus::MessageWriter writer(&method_call);
+    writer.AppendInt64(size);
+    proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+                       base::Bind(&VirtualFileProviderClientImpl::OnOpenFile,
+                                  weak_ptr_factory_.GetWeakPtr(),
+                                  base::Passed(std::move(callback))));
+  }
+
+ protected:
+  // DBusClient override.
+  void Init(dbus::Bus* bus) override {
+    proxy_ = bus->GetObjectProxy(
+        virtual_file_provider::kVirtualFileProviderServiceName,
+        dbus::ObjectPath(
+            virtual_file_provider::kVirtualFileProviderServicePath));
+  }
+
+ private:
+  // Runs the callback with OpenFile method call result.
+  void OnOpenFile(OpenFileCallback callback, dbus::Response* response) {
+    if (!response) {
+      std::move(callback).Run(std::string(), base::ScopedFD());
+      return;
+    }
+    dbus::MessageReader reader(response);
+    std::string id;
+    base::ScopedFD fd;
+    if (!reader.PopString(&id) || !reader.PopFileDescriptor(&fd)) {
+      LOG(ERROR) << "Invalid method call result.";
+      std::move(callback).Run(std::string(), base::ScopedFD());
+      return;
+    }
+    std::move(callback).Run(id, std::move(fd));
+  }
+
+  dbus::ObjectProxy* proxy_ = nullptr;
+
+  base::WeakPtrFactory<VirtualFileProviderClientImpl> weak_ptr_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(VirtualFileProviderClientImpl);
+};
+
+}  // namespace
+
+VirtualFileProviderClient::VirtualFileProviderClient() = default;
+
+VirtualFileProviderClient::~VirtualFileProviderClient() = default;
+
+// static
+VirtualFileProviderClient* VirtualFileProviderClient::Create() {
+  return new VirtualFileProviderClientImpl();
+}
+
+}  // namespace chromeos

chromeos/dbus/virtual_file_provider_client.h

+// Copyright 2017 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.
+
+#ifndef CHROMEOS_DBUS_VIRTUAL_FILE_PROVIDER_CLIENT_H_
+#define CHROMEOS_DBUS_VIRTUAL_FILE_PROVIDER_CLIENT_H_
+
+#include <stdint.h>
+
+#include <string>
+
+#include "base/callback_forward.h"
+#include "base/files/scoped_file.h"
+#include "base/macros.h"
+#include "chromeos/chromeos_export.h"
+#include "chromeos/dbus/dbus_client.h"
+
+namespace chromeos {
+
+// VirtualFileProviderClient is used to communicate with the VirtualFileProvider
+// service. The VirtualFileProvider service provides file descriptors which
+// forward read requests to Chrome. From the reading process's perspective, the
+// file descriptor behaves like a regular file descriptor (unlike a pipe, it
+// supports seek), while actually there is no real file associated with it.
+class CHROMEOS_EXPORT VirtualFileProviderClient : public DBusClient {
+ public:
+  using OpenFileCallback =
+      base::OnceCallback<void(const std::string& id, base::ScopedFD fd)>;
+
+  VirtualFileProviderClient();
+  ~VirtualFileProviderClient() override;
+
+  // Factory function, creates a new instance and returns ownership.
+  // For normal usage, access the singleton via DBusThreadManager::Get().
+  static VirtualFileProviderClient* Create();
+
+  // Creates a new file descriptor and returns it with a unique ID.
+  // |size| will be used to perform boundary check when FD is seeked.
+  // When the FD is read, the read request is forwarded to the request handler.
+  virtual void OpenFile(int64_t size, OpenFileCallback callback) = 0;
+};
+
+}  // namespace chromeos
+
+#endif  // CHROMEOS_DBUS_VIRTUAL_FILE_PROVIDER_CLIENT_H_