dbus: plumbing for {Enable,Query}AdbSideload methods

Test: build, method call from local change works
Bug: chromium:893332
Change-Id: Ice4072d878a91707bf86f3ba3a738068646977be
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1765656Reviewed-by: Alexander Alekseev <alemate@chromium.org>
Auto-Submit: Victor Hsieh <victorhsieh@chromium.org>
Commit-Queue: Victor Hsieh <victorhsieh@chromium.org>
Cr-Commit-Position: refs/heads/master@{#697004}

chromeos/dbus/session_manager/fake_session_manager_client.cc

@@ -675,6 +675,12 @@ void FakeSessionManagerClient::GetArcStartTime(
       arc_available_ ? base::make_optional(arc_start_time_) : base::nullopt);
 }
 
+void FakeSessionManagerClient::EnableAdbSideload(
+    EnableAdbSideloadCallback callback) {}
+
+void FakeSessionManagerClient::QueryAdbSideload(
+    QueryAdbSideloadCallback callback) {}
+
 void FakeSessionManagerClient::NotifyArcInstanceStopped() {
   for (auto& observer : observers_)
     observer.ArcInstanceStopped();

chromeos/dbus/session_manager/fake_session_manager_client.h

@@ -135,6 +135,8 @@ class COMPONENT_EXPORT(SESSION_MANAGER) FakeSessionManagerClient
   void EmitArcBooted(const cryptohome::AccountIdentifier& cryptohome_id,
                      VoidDBusMethodCallback callback) override;
   void GetArcStartTime(DBusMethodCallback<base::TimeTicks> callback) override;
+  void EnableAdbSideload(EnableAdbSideloadCallback callback) override;
+  void QueryAdbSideload(QueryAdbSideloadCallback callback) override;
 
   // Notifies observers as if ArcInstanceStopped signal is received.
   void NotifyArcInstanceStopped();

chromeos/dbus/session_manager/session_manager_client.cc

@@ -623,6 +623,28 @@ class SessionManagerClientImpl : public SessionManagerClient {
                        weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
   }
 
+  void EnableAdbSideload(EnableAdbSideloadCallback callback) override {
+    dbus::MethodCall method_call(
+        login_manager::kSessionManagerInterface,
+        login_manager::kSessionManagerEnableAdbSideload);
+
+    session_manager_proxy_->CallMethodWithErrorResponse(
+        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+        base::BindOnce(&SessionManagerClientImpl::OnEnableAdbSideload,
+                       weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
+  }
+
+  void QueryAdbSideload(QueryAdbSideloadCallback callback) override {
+    dbus::MethodCall method_call(
+        login_manager::kSessionManagerInterface,
+        login_manager::kSessionManagerQueryAdbSideload);
+
+    session_manager_proxy_->CallMethodWithErrorResponse(
+        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+        base::BindOnce(&SessionManagerClientImpl::OnQueryAdbSideload,
+                       weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
+  }
+
   void Init(dbus::Bus* bus) {
     session_manager_proxy_ = bus->GetObjectProxy(
         login_manager::kSessionManagerServiceName,
@@ -978,6 +1000,45 @@ class SessionManagerClientImpl : public SessionManagerClient {
     std::move(callback).Run(base::TimeTicks::FromInternalValue(ticks));
   }
 
+  void OnEnableAdbSideload(EnableAdbSideloadCallback callback,
+                           dbus::Response* response,
+                           dbus::ErrorResponse* error) {
+    if (!response) {
+      LOG(ERROR) << "Failed to call EnableAdbSideload: "
+                 << (error ? error->ToString() : "(null)");
+      std::move(callback).Run(false);
+      return;
+    }
+
+    bool succeeded;
+    dbus::MessageReader reader(response);
+    if (!reader.PopBool(&succeeded)) {
+      LOG(ERROR) << "Failed to enable sideloading";
+      std::move(callback).Run(false);
+      return;
+    }
+    std::move(callback).Run(true);
+  }
+
+  void OnQueryAdbSideload(QueryAdbSideloadCallback callback,
+                          dbus::Response* response,
+                          dbus::ErrorResponse* error) {
+    if (!response) {
+      LOG(ERROR) << "Failed to call QueryAdbSideload: "
+                 << (error ? error->ToString() : "(null)");
+      std::move(callback).Run(false, false);
+      return;
+    }
+
+    bool is_allowed;
+    dbus::MessageReader reader(response);
+    if (!reader.PopBool(&is_allowed)) {
+      LOG(ERROR) << "Failed to interpret the response";
+      std::move(callback).Run(false, false);
+    }
+    std::move(callback).Run(true, is_allowed);
+  }
+
   dbus::ObjectProxy* session_manager_proxy_ = nullptr;
   std::unique_ptr<BlockingMethodCaller> blocking_method_caller_;
   base::ObserverList<Observer>::Unchecked observers_;

chromeos/dbus/session_manager/session_manager_client.h

@@ -421,6 +421,23 @@ class COMPONENT_EXPORT(SESSION_MANAGER) SessionManagerClient {
   virtual void GetArcStartTime(
       DBusMethodCallback<base::TimeTicks> callback) = 0;
 
+  using EnableAdbSideloadCallback = base::OnceCallback<void(bool succeeded)>;
+
+  // Asynchronously attempts to enable ARC APK Sideloading. Upon completion,
+  // invokes |callback| with the result; true on success, false on failure of
+  // any kind.
+  virtual void EnableAdbSideload(EnableAdbSideloadCallback callback) = 0;
+
+  using QueryAdbSideloadCallback =
+      base::OnceCallback<void(bool succeeded, bool is_allowed)>;
+
+  // Asynchronously queries for the current status of ARC APK Sideloading. Upon
+  // completion, invokes |callback| with |succeeded| indicating if the query
+  // could be completed. If |succeeded| is true, |is_allowed| contains the
+  // current status of whether ARC APK Sideloading is allowed on this device,
+  // based on previous explicit user opt-in.
+  virtual void QueryAdbSideload(QueryAdbSideloadCallback callback) = 0;
+
  protected:
   // Use Initialize/Shutdown instead.
   SessionManagerClient();