Add UpstartClient

chromeos/dbus/auth_policy_client.cc

 // Copyright (c) 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 "chromeos/dbus/auth_policy_client.h"
 
 #include "base/bind.h"
 #include "base/memory/weak_ptr.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 {
 
+const char kUpstartServiceName[] = "com.ubuntu.Upstart";

[hashimoto, 2016/11/08 00:12:26]

AuthPolicyClient should deal only with AuthPolicy service.
If you want to interact with Upstart, it should belong to a different client
class.

[Roman Sorokin (ftl), 2016/11/08 10:43:13]

Done.

+const char kUpstartObjectPath[] = "/com/ubuntu/Upstart/jobs/authpolicyd";
+const char kUpstartJobInterface[] = "com.ubuntu.Upstart0_6.Job";
+const char kUpstartStartMethod[] = "Start";
+
 class AuthPolicyClientImpl : public AuthPolicyClient {
  public:
   AuthPolicyClientImpl() : weak_ptr_factory_(this) {}
 
   ~AuthPolicyClientImpl() override {}
 
   // AuthPolicyClient override.
+  void StartService() override {
+    dbus::ObjectPath objectPath(kUpstartObjectPath);
+    dbus::ObjectProxy* proxy =
+        bus_->GetObjectProxy(kUpstartServiceName, objectPath);
+    dbus::MethodCall method_call(kUpstartJobInterface, kUpstartStartMethod);
+    dbus::MessageWriter writer(&method_call);
+    dbus::MessageWriter sub_writer(nullptr);
+    writer.OpenArray("s", &sub_writer);
+    writer.CloseContainer(&sub_writer);
+    writer.AppendBool(false);  // No waiting for response.
+    proxy->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+                      base::Bind(&AuthPolicyClientImpl::HandleUpstartCallback,
+                                 weak_ptr_factory_.GetWeakPtr()));
+  }
   void JoinAdDomain(const std::string& machine_name,
                     const std::string& user,
                     int password_fd,
                     const JoinCallback& callback) override {
     dbus::ObjectPath objectPath(authpolicy::kAuthPolicyServicePath);
     dbus::ObjectProxy* proxy =
         bus_->GetObjectProxy(authpolicy::kAuthPolicyServiceName, objectPath);
     dbus::MethodCall method_call(authpolicy::kAuthPolicyInterface,
                                  authpolicy::kAuthPolicyJoinADDomain);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(machine_name);
     writer.AppendString(user);
     writer.AppendFileDescriptor(password_fd);
     proxy->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
                       base::Bind(&AuthPolicyClientImpl::HandleJoinCallback,
                                  weak_ptr_factory_.GetWeakPtr(), callback));
   }
 
  protected:
   void Init(dbus::Bus* bus) override { bus_ = bus; }
 
  private:
+  void HandleUpstartCallback(dbus::Response* response) {
+    if (!response) {
+      LOG(ERROR) << "Failed to start authpolicyd, response is null";
+      return;
+    }
+  }
   void HandleJoinCallback(const JoinCallback& callback,
                           dbus::Response* response) {
     if (!response) {
       LOG(ERROR) << "Join: Couldn't call to authpolicy";
       // TODO(rsorokin): make proper call, after defining possible errors codes.
       callback.Run(authpolicy::AD_JOIN_ERROR_UNKNOWN);
       return;
     }
 
     dbus::MessageReader reader(response);
@@ skipping 22 matching lines @@
 AuthPolicyClient::AuthPolicyClient() {}
 
 AuthPolicyClient::~AuthPolicyClient() {}
 
 // static
 AuthPolicyClient* AuthPolicyClient::Create() {
   return new AuthPolicyClientImpl();
 }
 
 }  // namespace chromeos