dlcservice: Add GetDlcState to dlcservice client.

Add GetDlcState method to client as well as fake client and associated unittests.

TEST=b:172223380
BUG=autoninja -C out/Default/ unit_tests &&  ./out/Default/unit_tests --gtest_filter=*Dlc*


dlcservice: 
Change-Id: I6f26c75e7d73447d14e724558a1f381198de88d4
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2540367Reviewed-by: Steven Bennetts <stevenjb@chromium.org>
Commit-Queue: Vyshu Khota <vyshu@google.com>
Cr-Commit-Position: refs/heads/master@{#827881}

chromeos/dbus/dlcservice/dlcservice_client.cc

@@ -172,6 +172,20 @@ class DlcserviceClientImpl : public DlcserviceClient {
                        std::move(purge_callback)));
   }
 
+  void GetDlcState(const std::string& dlc_id,
+                   GetDlcStateCallback callback) override {
+    CheckServiceAvailable("GetDlcState");
+    dbus::MethodCall method_call(dlcservice::kDlcServiceInterface,
+                                 dlcservice::kGetDlcStateMethod);
+    dbus::MessageWriter writer(&method_call);
+    writer.AppendString(dlc_id);
+    VLOG(1) << "Requesting DLC state of" << dlc_id;
+    dlcservice_proxy_->CallMethodWithErrorResponse(
+        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+        base::BindOnce(&DlcserviceClientImpl::OnGetDlcState,
+                       weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
+  }
+
   void GetExistingDlcs(GetExistingDlcsCallback callback) override {
     CheckServiceAvailable("GetExistingDlcs");
     dbus::MethodCall method_call(dlcservice::kDlcServiceInterface,
@@ -377,6 +391,20 @@ class DlcserviceClientImpl : public DlcserviceClient {
                       : DlcserviceErrorResponseHandler(err_response).get_err());
   }
 
+  void OnGetDlcState(GetDlcStateCallback callback,
+                     dbus::Response* response,
+                     dbus::ErrorResponse* err_response) {
+    dlcservice::DlcState dlc_state;
+    if (response &&
+        dbus::MessageReader(response).PopArrayOfBytesAsProto(&dlc_state)) {
+      std::move(callback).Run(dlcservice::kErrorNone, dlc_state);
+    } else {
+      std::move(callback).Run(
+          DlcserviceErrorResponseHandler(err_response).get_err(),
+          dlcservice::DlcState());
+    }
+  }
+
   void OnGetExistingDlcs(GetExistingDlcsCallback callback,
                          dbus::Response* response,
                          dbus::ErrorResponse* err_response) {

chromeos/dbus/dlcservice/dlcservice_client.h

@@ -76,6 +76,12 @@ class COMPONENT_EXPORT(DLCSERVICE_CLIENT) DlcserviceClient {
   // |dlcservice::kErrorNone| the call has failed.
   using PurgeCallback = base::OnceCallback<void(const std::string& err)>;
 
+  // The callback used for |GetDlcState()|, if the error is something other
+  // than |dlcservice::kErrorNone| the call has failed.
+  using GetDlcStateCallback =
+      base::OnceCallback<void(const std::string& err,
+                              const dlcservice::DlcState& dlc_state)>;
+
   // The callback used for |GetExistingDlcs()|, if the error is something other
   // than |dlcservice::kErrorNone| the call has failed. It is a very rare case
   // for |GetExistingDlcs()| call to fail.
@@ -104,6 +110,11 @@ class COMPONENT_EXPORT(DLCSERVICE_CLIENT) DlcserviceClient {
   virtual void Purge(const std::string& dlc_id,
                      PurgeCallback purge_callback) = 0;
 
+  // Returns the state of a single DLC. Including information
+  // such as installation state, id, and verification state.
+  virtual void GetDlcState(const std::string& dlc_id,
+                           GetDlcStateCallback callback) = 0;
+
   // Provides the DLC(s) information such as:
   // id, name, description, used_bytes_on_disk. (reference
   // |dlcservice::DlcsWithContent| proto for complete details)

chromeos/dbus/dlcservice/dlcservice_client_unittest.cc

@@ -127,6 +127,55 @@ class MockObserver : public DlcserviceClient::Observer {
               ());
 };
 
+TEST_F(DlcserviceClientTest, GetDlcStateSuccessTest) {
+  responses_.push_back(dbus::Response::CreateEmpty());
+  dbus::Response* response = responses_.front().get();
+  dbus::MessageWriter writer(response);
+  dlcservice::DlcState dlc_state;
+  writer.AppendProtoAsArrayOfBytes(dlc_state);
+
+  EXPECT_CALL(*mock_proxy_.get(), DoCallMethodWithErrorResponse(_, _, _))
+      .WillOnce(
+          Invoke(this, &DlcserviceClientTest::CallMethodWithErrorResponse));
+
+  DlcserviceClient::GetDlcStateCallback callback =
+      base::BindOnce([](const std::string& err, const dlcservice::DlcState&) {
+        EXPECT_EQ(dlcservice::kErrorNone, err);
+      });
+  client_->GetDlcState("some-dlc-id", std::move(callback));
+  base::RunLoop().RunUntilIdle();
+}
+
+TEST_F(DlcserviceClientTest, GetDlcStateFailureTest) {
+  dbus::MethodCall method_call(dlcservice::kDlcServiceInterface,
+                               dlcservice::kGetDlcStateMethod);
+  method_call.SetSerial(123);
+  err_responses_.push_back(dbus::ErrorResponse::FromMethodCall(
+      &method_call, DBUS_ERROR_FAILED, "some-unknown-error"));
+
+  EXPECT_CALL(*mock_proxy_.get(), DoCallMethodWithErrorResponse(_, _, _))
+      .WillRepeatedly(
+          Invoke(this, &DlcserviceClientTest::CallMethodWithErrorResponse));
+
+  client_->GetDlcState(
+      "some-dlc-id",
+      base::BindOnce([](const std::string& err, const dlcservice::DlcState&) {
+        EXPECT_EQ(dlcservice::kErrorInternal, err);
+      }));
+  base::RunLoop().RunUntilIdle();
+
+  err_responses_.push_back(dbus::ErrorResponse::FromMethodCall(
+      &method_call, dlcservice::kErrorInvalidDlc,
+      "Some error due to bad DLC."));
+
+  client_->GetDlcState(
+      "some-dlc-id",
+      base::BindOnce([](const std::string& err, const dlcservice::DlcState&) {
+        EXPECT_EQ(dlcservice::kErrorInvalidDlc, err);
+      }));
+  base::RunLoop().RunUntilIdle();
+}
+
 TEST_F(DlcserviceClientTest, GetExistingDlcsSuccessTest) {
   responses_.push_back(dbus::Response::CreateEmpty());
   dbus::Response* response = responses_.front().get();

chromeos/dbus/dlcservice/fake_dlcservice_client.cc

@@ -52,6 +52,14 @@ void FakeDlcserviceClient::Purge(const std::string& dlc_id,
       FROM_HERE, base::BindOnce(std::move(callback), purge_err_));
 }
 
+void FakeDlcserviceClient::GetDlcState(const std::string& dlc_id,
+                                       GetDlcStateCallback callback) {
+  VLOG(1) << "Requesting to get DLC state of" << dlc_id;
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE,
+      base::BindOnce(std::move(callback), get_dlc_state_err_, dlc_state_));
+}
+
 void FakeDlcserviceClient::GetExistingDlcs(GetExistingDlcsCallback callback) {
   VLOG(1) << "Requesting to get existing DLC(s).";
   base::ThreadTaskRunnerHandle::Get()->PostTask(

chromeos/dbus/dlcservice/fake_dlcservice_client.h

@@ -29,6 +29,8 @@ class COMPONENT_EXPORT(DLCSERVICE_CLIENT) FakeDlcserviceClient
                  UninstallCallback callback) override;
   // Purging removes the DLC entirely from disk.
   void Purge(const std::string& dlc_id, PurgeCallback callback) override;
+  void GetDlcState(const std::string& dlc_if,
+                   GetDlcStateCallback callback) override;
   void GetExistingDlcs(GetExistingDlcsCallback callback) override;
   void DlcStateChangedForTest(dbus::Signal* signal) override;
   void AddObserver(Observer* observer) override;
@@ -43,6 +45,9 @@ class COMPONENT_EXPORT(DLCSERVICE_CLIENT) FakeDlcserviceClient
   }
   void set_uninstall_error(const std::string& err) { uninstall_err_ = err; }
   void set_purge_error(const std::string& err) { purge_err_ = err; }
+  void set_get_dlc_state_error(const std::string& err) {
+    get_dlc_state_err_ = err;
+  }
   void set_get_existing_dlcs_error(const std::string& err) {
     get_existing_dlcs_err_ = err;
   }
@@ -55,10 +60,12 @@ class COMPONENT_EXPORT(DLCSERVICE_CLIENT) FakeDlcserviceClient
   std::string install_err_ = dlcservice::kErrorNone;
   std::string uninstall_err_ = dlcservice::kErrorNone;
   std::string purge_err_ = dlcservice::kErrorNone;
+  std::string get_dlc_state_err_ = dlcservice::kErrorNone;
   std::string get_installed_err_ = dlcservice::kErrorNone;
   std::string get_existing_dlcs_err_ = dlcservice::kErrorNone;
   std::string install_root_path_;
   dlcservice::DlcsWithContent dlcs_with_content_;
+  dlcservice::DlcState dlc_state_;
 
   // A list of observers that are listening on state changes, etc.
   base::ObserverList<Observer> observers_;