Create SeneschalClient to be used by FilesApp.

FilesApp will  share folders with crostini container using 9p fileserver.

Bug: 878324
Change-Id: I7e10af12cab26f050fe95073f667f1d1104f7392
Reviewed-on: https://chromium-review.googlesource.com/1193166Reviewed-by: Dan Erat <derat@chromium.org>
Reviewed-by: Nicholas Verne <nverne@chromium.org>
Commit-Queue: Joel Hockey <joelhockey@chromium.org>
Cr-Commit-Position: refs/heads/master@{#588279}

chromeos/BUILD.gn

@@ -31,6 +31,7 @@ component("chromeos") {
     ":login_manager_proto",
     ":media_perception_proto",
     ":power_manager_proto",
+    ":seneschal_proto",
     ":smbprovider_proto",
     ":vm_applications_apps_proto",
     "//base",
@@ -230,6 +231,8 @@ component("chromeos") {
     "dbus/fake_permission_broker_client.h",
     "dbus/fake_power_manager_client.cc",
     "dbus/fake_power_manager_client.h",
+    "dbus/fake_seneschal_client.cc",
+    "dbus/fake_seneschal_client.h",
     "dbus/fake_session_manager_client.cc",
     "dbus/fake_session_manager_client.h",
     "dbus/fake_shill_device_client.cc",
@@ -280,6 +283,8 @@ component("chromeos") {
     "dbus/power_manager_client.h",
     "dbus/power_policy_controller.cc",
     "dbus/power_policy_controller.h",
+    "dbus/seneschal_client.cc",
+    "dbus/seneschal_client.h",
     "dbus/services/cros_dbus_service.cc",
     "dbus/services/cros_dbus_service.h",
     "dbus/session_manager_client.cc",
@@ -949,6 +954,14 @@ proto_library("media_perception_proto") {
   proto_out_dir = "chromeos/dbus/media_perception"
 }
 
+proto_library("seneschal_proto") {
+  sources = [
+    "//third_party/cros_system_api/dbus/seneschal/seneschal_service.proto",
+  ]
+
+  proto_out_dir = "chromeos/dbus/seneschal"
+}
+
 proto_library("smbprovider_proto") {
   sources = [
     "//third_party/cros_system_api/dbus/smbprovider/directory_entry.proto",

chromeos/dbus/dbus_clients_browser.cc

@@ -31,6 +31,7 @@
 #include "chromeos/dbus/fake_lorgnette_manager_client.h"
 #include "chromeos/dbus/fake_media_analytics_client.h"
 #include "chromeos/dbus/fake_oobe_configuration_client.h"
+#include "chromeos/dbus/fake_seneschal_client.h"
 #include "chromeos/dbus/fake_smb_provider_client.h"
 #include "chromeos/dbus/fake_virtual_file_provider_client.h"
 #include "chromeos/dbus/image_burner_client.h"
@@ -38,6 +39,7 @@
 #include "chromeos/dbus/lorgnette_manager_client.h"
 #include "chromeos/dbus/media_analytics_client.h"
 #include "chromeos/dbus/oobe_configuration_client.h"
+#include "chromeos/dbus/seneschal_client.h"
 #include "chromeos/dbus/smb_provider_client.h"
 #include "chromeos/dbus/virtual_file_provider_client.h"
 
@@ -120,6 +122,11 @@ DBusClientsBrowser::DBusClientsBrowser(bool use_real_clients) {
   else
     oobe_configuration_client_.reset(new FakeOobeConfigurationClient);
 
+  if (use_real_clients)
+    seneschal_client_ = SeneschalClient::Create();
+  else
+    seneschal_client_ = std::make_unique<FakeSeneschalClient>();
+
   if (use_real_clients)
     smb_provider_client_.reset(SmbProviderClient::Create());
   else
@@ -151,6 +158,7 @@ void DBusClientsBrowser::Initialize(dbus::Bus* system_bus) {
   lorgnette_manager_client_->Init(system_bus);
   media_analytics_client_->Init(system_bus);
   oobe_configuration_client_->Init(system_bus);
+  seneschal_client_->Init(system_bus);
   smb_provider_client_->Init(system_bus);
   virtual_file_provider_client_->Init(system_bus);
 }

chromeos/dbus/dbus_clients_browser.h

@@ -31,6 +31,7 @@ class ImageLoaderClient;
 class LorgnetteManagerClient;
 class MediaAnalyticsClient;
 class OobeConfigurationClient;
+class SeneschalClient;
 class SmbProviderClient;
 class VirtualFileProviderClient;
 
@@ -64,6 +65,7 @@ class CHROMEOS_EXPORT DBusClientsBrowser {
   std::unique_ptr<LorgnetteManagerClient> lorgnette_manager_client_;
   std::unique_ptr<MediaAnalyticsClient> media_analytics_client_;
   std::unique_ptr<OobeConfigurationClient> oobe_configuration_client_;
+  std::unique_ptr<SeneschalClient> seneschal_client_;
   std::unique_ptr<SmbProviderClient> smb_provider_client_;
   std::unique_ptr<VirtualFileProviderClient> virtual_file_provider_client_;
 

chromeos/dbus/dbus_thread_manager.cc

@@ -38,6 +38,7 @@
 #include "chromeos/dbus/modem_messaging_client.h"
 #include "chromeos/dbus/permission_broker_client.h"
 #include "chromeos/dbus/power_manager_client.h"
+#include "chromeos/dbus/seneschal_client.h"
 #include "chromeos/dbus/session_manager_client.h"
 #include "chromeos/dbus/shill_device_client.h"
 #include "chromeos/dbus/shill_ipconfig_client.h"
@@ -258,6 +259,10 @@ SessionManagerClient* DBusThreadManager::GetSessionManagerClient() {
   return clients_common_->session_manager_client_.get();
 }
 
+SeneschalClient* DBusThreadManager::GetSeneschalClient() {
+  return clients_browser_ ? clients_browser_->seneschal_client_.get() : nullptr;
+}
+
 SmbProviderClient* DBusThreadManager::GetSmbProviderClient() {
   return clients_browser_ ? clients_browser_->smb_provider_client_.get()
                           : nullptr;
@@ -419,6 +424,12 @@ void DBusThreadManagerSetter::SetHammerdClient(
       std::move(client);
 }
 
+void DBusThreadManagerSetter::SetSeneschalClient(
+    std::unique_ptr<SeneschalClient> client) {
+  DBusThreadManager::Get()->clients_browser_->seneschal_client_ =
+      std::move(client);
+}
+
 void DBusThreadManagerSetter::SetShillDeviceClient(
     std::unique_ptr<ShillDeviceClient> client) {
   DBusThreadManager::Get()->clients_common_->shill_device_client_ =

chromeos/dbus/dbus_thread_manager.h

@@ -52,6 +52,7 @@ class ModemMessagingClient;
 class OobeConfigurationClient;
 class PermissionBrokerClient;
 class PowerManagerClient;
+class SeneschalClient;
 class SessionManagerClient;
 class ShillDeviceClient;
 class ShillIPConfigClient;
@@ -158,6 +159,7 @@ class CHROMEOS_EXPORT DBusThreadManager {
   OobeConfigurationClient* GetOobeConfigurationClient();
   PermissionBrokerClient* GetPermissionBrokerClient();
   PowerManagerClient* GetPowerManagerClient();
+  SeneschalClient* GetSeneschalClient();
   SessionManagerClient* GetSessionManagerClient();
   ShillDeviceClient* GetShillDeviceClient();
   ShillIPConfigClient* GetShillIPConfigClient();
@@ -213,20 +215,21 @@ class CHROMEOS_EXPORT DBusThreadManagerSetter {
   void SetCryptohomeClient(std::unique_ptr<CryptohomeClient> client);
   void SetDebugDaemonClient(std::unique_ptr<DebugDaemonClient> client);
   void SetHammerdClient(std::unique_ptr<HammerdClient> client);
-  void SetShillDeviceClient(std::unique_ptr<ShillDeviceClient> client);
-  void SetShillIPConfigClient(std::unique_ptr<ShillIPConfigClient> client);
-  void SetShillManagerClient(std::unique_ptr<ShillManagerClient> client);
-  void SetShillServiceClient(std::unique_ptr<ShillServiceClient> client);
-  void SetShillProfileClient(std::unique_ptr<ShillProfileClient> client);
-  void SetShillThirdPartyVpnDriverClient(
-      std::unique_ptr<ShillThirdPartyVpnDriverClient> client);
   void SetImageBurnerClient(std::unique_ptr<ImageBurnerClient> client);
   void SetImageLoaderClient(std::unique_ptr<ImageLoaderClient> client);
   void SetMediaAnalyticsClient(std::unique_ptr<MediaAnalyticsClient> client);
   void SetPermissionBrokerClient(
       std::unique_ptr<PermissionBrokerClient> client);
   void SetPowerManagerClient(std::unique_ptr<PowerManagerClient> client);
+  void SetSeneschalClient(std::unique_ptr<SeneschalClient> client);
   void SetSessionManagerClient(std::unique_ptr<SessionManagerClient> client);
+  void SetShillDeviceClient(std::unique_ptr<ShillDeviceClient> client);
+  void SetShillIPConfigClient(std::unique_ptr<ShillIPConfigClient> client);
+  void SetShillManagerClient(std::unique_ptr<ShillManagerClient> client);
+  void SetShillServiceClient(std::unique_ptr<ShillServiceClient> client);
+  void SetShillProfileClient(std::unique_ptr<ShillProfileClient> client);
+  void SetShillThirdPartyVpnDriverClient(
+      std::unique_ptr<ShillThirdPartyVpnDriverClient> client);
   void SetSmbProviderClient(std::unique_ptr<SmbProviderClient> client);
   void SetSystemClockClient(std::unique_ptr<SystemClockClient> client);
   void SetUpdateEngineClient(std::unique_ptr<UpdateEngineClient> client);

chromeos/dbus/dbus_thread_manager_unittest.cc

@@ -36,6 +36,7 @@ TEST(DBusThreadManagerTest, Initialize) {
   EXPECT_TRUE(manager->GetModemMessagingClient());
   EXPECT_TRUE(manager->GetPermissionBrokerClient());
   EXPECT_TRUE(manager->GetPowerManagerClient());
+  EXPECT_TRUE(manager->GetSeneschalClient());
   EXPECT_TRUE(manager->GetSessionManagerClient());
   EXPECT_TRUE(manager->GetShillDeviceClient());
   EXPECT_TRUE(manager->GetShillIPConfigClient());
@@ -86,6 +87,7 @@ TEST(DBusThreadManagerTest, InitializeForBrowser) {
   EXPECT_TRUE(manager->GetEasyUnlockClient());
   EXPECT_TRUE(manager->GetImageBurnerClient());
   EXPECT_TRUE(manager->GetLorgnetteManagerClient());
+  EXPECT_TRUE(manager->GetSeneschalClient());
 
   DBusThreadManager::Shutdown();
 }
@@ -125,6 +127,7 @@ TEST(DBusThreadManagerTest, InitializeForAsh) {
   EXPECT_FALSE(manager->GetEasyUnlockClient());
   EXPECT_FALSE(manager->GetImageBurnerClient());
   EXPECT_FALSE(manager->GetLorgnetteManagerClient());
+  EXPECT_FALSE(manager->GetSeneschalClient());
 
   DBusThreadManager::Shutdown();
 }

chromeos/dbus/fake_seneschal_client.cc

+// Copyright 2018 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_seneschal_client.h"
+
+#include <utility>
+
+#include "base/threading/thread_task_runner_handle.h"
+
+namespace chromeos {
+
+FakeSeneschalClient::FakeSeneschalClient() {
+  share_path_response_.set_success(true);
+  share_path_response_.set_path("foo");
+}
+
+FakeSeneschalClient::~FakeSeneschalClient() = default;
+
+void FakeSeneschalClient::SharePath(
+    const vm_tools::seneschal::SharePathRequest& request,
+    DBusMethodCallback<vm_tools::seneschal::SharePathResponse> callback) {
+  share_path_called_ = true;
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::BindOnce(std::move(callback), share_path_response_));
+}
+
+}  // namespace chromeos

chromeos/dbus/fake_seneschal_client.h

+// Copyright 2018 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_SENESCHAL_CLIENT_H_
+#define CHROMEOS_DBUS_FAKE_SENESCHAL_CLIENT_H_
+
+#include "base/observer_list.h"
+#include "chromeos/dbus/seneschal_client.h"
+
+namespace chromeos {
+
+// FakeSeneschalClient is a stub implementation of SeneschalClient used for
+// testing.
+class CHROMEOS_EXPORT FakeSeneschalClient : public SeneschalClient {
+ public:
+  FakeSeneschalClient();
+  ~FakeSeneschalClient() override;
+
+  // SeneschalClient:
+  void SharePath(const vm_tools::seneschal::SharePathRequest& request,
+                 DBusMethodCallback<vm_tools::seneschal::SharePathResponse>
+                     callback) override;
+
+  bool share_path_called() const { return share_path_called_; }
+
+  void set_share_path_response(
+      const vm_tools::seneschal::SharePathResponse& share_path_response) {
+    share_path_response_ = share_path_response;
+  }
+
+ protected:
+  void Init(dbus::Bus* bus) override {}
+
+ private:
+  void InitializeProtoResponses();
+
+  bool share_path_called_ = false;
+
+  vm_tools::seneschal::SharePathResponse share_path_response_;
+
+  DISALLOW_COPY_AND_ASSIGN(FakeSeneschalClient);
+};
+
+}  // namespace chromeos
+
+#endif  // CHROMEOS_DBUS_FAKE_SENESCHAL_CLIENT_H_

chromeos/dbus/seneschal_client.cc

+// Copyright 2018 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/seneschal_client.h"
+
+#include <memory>
+
+#include "base/bind.h"
+#include "base/location.h"
+#include "base/memory/weak_ptr.h"
+#include "base/threading/thread_task_runner_handle.h"
+#include "dbus/bus.h"
+#include "dbus/message.h"
+#include "dbus/object_proxy.h"
+#include "third_party/cros_system_api/dbus/seneschal/dbus-constants.h"
+
+namespace chromeos {
+
+class SeneschalClientImpl : public SeneschalClient {
+ public:
+  SeneschalClientImpl() : weak_ptr_factory_(this) {}
+
+  ~SeneschalClientImpl() override = default;
+
+  void SharePath(const vm_tools::seneschal::SharePathRequest& request,
+                 DBusMethodCallback<vm_tools::seneschal::SharePathResponse>
+                     callback) override {
+    dbus::MethodCall method_call(vm_tools::seneschal::kSeneschalInterface,
+                                 vm_tools::seneschal::kSharePathMethod);
+    dbus::MessageWriter writer(&method_call);
+
+    if (!writer.AppendProtoAsArrayOfBytes(request)) {
+      LOG(ERROR) << "Failed to encode SharePath protobuf";
+      base::ThreadTaskRunnerHandle::Get()->PostTask(
+          FROM_HERE, base::BindOnce(std::move(callback), base::nullopt));
+      return;
+    }
+
+    seneschal_proxy_->CallMethod(
+        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+        base::BindOnce(&SeneschalClientImpl::OnDBusProtoResponse<
+                           vm_tools::seneschal::SharePathResponse>,
+                       weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
+  }
+
+ protected:
+  void Init(dbus::Bus* bus) override {
+    seneschal_proxy_ = bus->GetObjectProxy(
+        vm_tools::seneschal::kSeneschalServiceName,
+        dbus::ObjectPath(vm_tools::seneschal::kSeneschalServicePath));
+  }
+
+ private:
+  template <typename ResponseProto>
+  void OnDBusProtoResponse(DBusMethodCallback<ResponseProto> callback,
+                           dbus::Response* dbus_response) {
+    if (!dbus_response) {
+      std::move(callback).Run(base::nullopt);
+      return;
+    }
+    ResponseProto reponse_proto;
+    dbus::MessageReader reader(dbus_response);
+    if (!reader.PopArrayOfBytesAsProto(&reponse_proto)) {
+      LOG(ERROR) << "Failed to parse proto from " << dbus_response->GetMember();
+      std::move(callback).Run(base::nullopt);
+      return;
+    }
+    std::move(callback).Run(std::move(reponse_proto));
+  }
+
+  dbus::ObjectProxy* seneschal_proxy_ = nullptr;
+
+  // Note: This should remain the last member so it'll be destroyed and
+  // invalidate its weak pointers before any other members are destroyed.
+  base::WeakPtrFactory<SeneschalClientImpl> weak_ptr_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(SeneschalClientImpl);
+};
+
+SeneschalClient::SeneschalClient() = default;
+
+SeneschalClient::~SeneschalClient() = default;
+
+std::unique_ptr<SeneschalClient> SeneschalClient::Create() {
+  return std::make_unique<SeneschalClientImpl>();
+}
+
+}  // namespace chromeos

chromeos/dbus/seneschal_client.h

+// Copyright 2018 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_SENESCHAL_CLIENT_H_
+#define CHROMEOS_DBUS_SENESCHAL_CLIENT_H_
+
+#include "chromeos/chromeos_export.h"
+#include "chromeos/dbus/dbus_client.h"
+#include "chromeos/dbus/dbus_method_call_status.h"
+#include "chromeos/dbus/seneschal/seneschal_service.pb.h"
+
+namespace chromeos {
+
+// SeneschalClient is used to communicate with Seneschal, which manages
+// 9p file servers.
+class CHROMEOS_EXPORT SeneschalClient : public DBusClient {
+ public:
+  ~SeneschalClient() override;
+
+  // Factory function, creates a new instance and returns ownership.
+  // For normal usage, access the singleton via DBusThreadManager::Get().
+  static std::unique_ptr<SeneschalClient> Create();
+
+  // Shares a path in the Chrome OS host with the container.
+  // |callback| is called after the method call finishes.
+  virtual void SharePath(
+      const vm_tools::seneschal::SharePathRequest& request,
+      DBusMethodCallback<vm_tools::seneschal::SharePathResponse> callback) = 0;
+
+ protected:
+  // Create() should be used instead.
+  SeneschalClient();
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(SeneschalClient);
+};
+
+}  // namespace chromeos
+
+#endif  // CHROMEOS_DBUS_SENESCHAL_CLIENT_H_