Implemented new channel switcher UI.

chromeos/dbus/update_engine_client.cc

 // Copyright (c) 2012 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/update_engine_client.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/strings/string_util.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_path.h"
 #include "dbus/object_proxy.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
+
 namespace {
 
+const char kReleaseChannelDev[] = "dev-channel";
+const char kReleaseChannelBeta[] = "beta-channel";
+const char kReleaseChannelStable[] = "stable-channel";
+
 // Returns UPDATE_STATUS_ERROR on error.
 UpdateEngineClient::UpdateStatusOperation UpdateStatusFromString(
     const std::string& str) {
   if (str == "UPDATE_STATUS_IDLE")
     return UpdateEngineClient::UPDATE_STATUS_IDLE;
   if (str == "UPDATE_STATUS_CHECKING_FOR_UPDATE")
     return UpdateEngineClient::UPDATE_STATUS_CHECKING_FOR_UPDATE;
   if (str == "UPDATE_STATUS_UPDATE_AVAILABLE")
     return UpdateEngineClient::UPDATE_STATUS_UPDATE_AVAILABLE;
   if (str == "UPDATE_STATUS_DOWNLOADING")
     return UpdateEngineClient::UPDATE_STATUS_DOWNLOADING;
   if (str == "UPDATE_STATUS_VERIFYING")
     return UpdateEngineClient::UPDATE_STATUS_VERIFYING;
   if (str == "UPDATE_STATUS_FINALIZING")
     return UpdateEngineClient::UPDATE_STATUS_FINALIZING;
   if (str == "UPDATE_STATUS_UPDATED_NEED_REBOOT")
     return UpdateEngineClient::UPDATE_STATUS_UPDATED_NEED_REBOOT;
   if (str == "UPDATE_STATUS_REPORTING_ERROR_EVENT")
     return UpdateEngineClient::UPDATE_STATUS_REPORTING_ERROR_EVENT;
   return UpdateEngineClient::UPDATE_STATUS_ERROR;
 }
 
 // Used in UpdateEngineClient::EmptyUpdateCheckCallback().
 void EmptyUpdateCheckCallbackBody(
     UpdateEngineClient::UpdateCheckResult unused_result) {
 }
 
+bool IsValidChannel(const std::string& channel) {
+  return channel == kReleaseChannelDev ||
+      channel == kReleaseChannelBeta ||
+      channel == kReleaseChannelStable;
+}
+
 }  // namespace
 
 // The UpdateEngineClient implementation used in production.
 class UpdateEngineClientImpl : public UpdateEngineClient {
  public:
   explicit UpdateEngineClientImpl(dbus::Bus* bus)
       : update_engine_proxy_(NULL),
         last_status_(),
         weak_ptr_factory_(this) {
     update_engine_proxy_ = bus->GetObjectProxy(
@@ skipping 14 matching lines @@
     // Get update engine status for the initial status. Update engine won't
     // send StatusUpdate signal unless there is a status change. If chrome
     // crashes after UPDATE_STATUS_UPDATED_NEED_REBOOT status is set,
     // restarted chrome would not get this status. See crbug.com/154104.
     GetUpdateEngineStatus();
   }
 
   virtual ~UpdateEngineClientImpl() {
   }
 
-  // UpdateEngineClient override.
+  // UpdateEngineClient implementation:
   virtual void AddObserver(Observer* observer) OVERRIDE {
     observers_.AddObserver(observer);
   }
 
-  // UpdateEngineClient override.
   virtual void RemoveObserver(Observer* observer) OVERRIDE {
     observers_.RemoveObserver(observer);
   }
 
-  // UpdateEngineClient override.
   virtual bool HasObserver(Observer* observer) OVERRIDE {
     return observers_.HasObserver(observer);
   }
 
-  // UpdateEngineClient override.
   virtual void RequestUpdateCheck(
       const UpdateCheckCallback& callback) OVERRIDE {
     dbus::MethodCall method_call(
         update_engine::kUpdateEngineInterface,
         update_engine::kAttemptUpdate);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString("");  // Unused.
     writer.AppendString("");  // Unused.
 
     VLOG(1) << "Requesting an update check";
     update_engine_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&UpdateEngineClientImpl::OnRequestUpdateCheck,
                    weak_ptr_factory_.GetWeakPtr(),
                    callback));
   }
 
-  // UpdateEngineClient override.
   virtual void RebootAfterUpdate() OVERRIDE {
     dbus::MethodCall method_call(
         update_engine::kUpdateEngineInterface,
         update_engine::kRebootIfNeeded);
 
     VLOG(1) << "Requesting a reboot";
     update_engine_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&UpdateEngineClientImpl::OnRebootAfterUpdate,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
-  // UpdateEngineClient override.
   virtual void SetReleaseTrack(const std::string& track) OVERRIDE {
     dbus::MethodCall method_call(
         update_engine::kUpdateEngineInterface,
         update_engine::kSetTrack);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(track);
 
     VLOG(1) << "Requesting to set the release track to " << track;
     update_engine_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&UpdateEngineClientImpl::OnSetReleaseTrack,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
-  // UpdateEngineClient override.
   virtual void GetReleaseTrack(
       const GetReleaseTrackCallback& callback) OVERRIDE {
     dbus::MethodCall method_call(
         update_engine::kUpdateEngineInterface,
         update_engine::kGetTrack);
 
     VLOG(1) << "Requesting to get the current release track";
     update_engine_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&UpdateEngineClientImpl::OnGetReleaseTrack,
                    weak_ptr_factory_.GetWeakPtr(),
                    callback));
   }
 
-  // UpdateEngineClient override.
   virtual Status GetLastStatus() OVERRIDE {
     return last_status_;
   }
 
+  virtual void SetChannel(const std::string& target_channel,
+                          bool is_powerwash_allowed) OVERRIDE {
+    if (!IsValidChannel(target_channel)) {
+      LOG(ERROR) << "Invalid channel name: " << target_channel;
+      return;
+    }
+
+    dbus::MethodCall method_call(
+        update_engine::kUpdateEngineInterface,
+        update_engine::kSetChannel);
+    dbus::MessageWriter writer(&method_call);
+    writer.AppendString(target_channel);
+    writer.AppendBool(is_powerwash_allowed);
+
+    VLOG(1) << "Requesting to set channel: "
+            << "target_channel=" << target_channel << ", "
+            << "is_powerwash_allowed=" << is_powerwash_allowed;
+    update_engine_proxy_->CallMethod(
+        &method_call,
+        dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+        base::Bind(&UpdateEngineClientImpl::OnSetChannel,
+                   weak_ptr_factory_.GetWeakPtr()));
+  }
+
+  virtual void GetChannel(bool get_current_channel,
+                          const GetChannelCallback& callback) OVERRIDE {
+    dbus::MethodCall method_call(
+        update_engine::kUpdateEngineInterface,
+        update_engine::kGetChannel);
+    dbus::MessageWriter writer(&method_call);
+    writer.AppendBool(get_current_channel);
+
+    VLOG(1) << "Requesting to get channel, get_current_channel="
+            << get_current_channel;
+    update_engine_proxy_->CallMethod(
+        &method_call,
+        dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+        base::Bind(&UpdateEngineClientImpl::OnGetChannel,
+                   weak_ptr_factory_.GetWeakPtr(),
+                   callback));
+  }
+
  private:
   void GetUpdateEngineStatus() {
     dbus::MethodCall method_call(
         update_engine::kUpdateEngineInterface,
         update_engine::kGetStatus);
     update_engine_proxy_->CallMethodWithErrorCallback(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&UpdateEngineClientImpl::OnGetStatus,
                    weak_ptr_factory_.GetWeakPtr()),
@@ skipping 69 matching lines @@
     status.status = UpdateStatusFromString(current_operation);
     last_status_ = status;
     FOR_EACH_OBSERVER(Observer, observers_, UpdateStatusChanged(status));
   }
 
   // Called when GetStatus call failed.
   void OnGetStatusError(dbus::ErrorResponse* error) {
     LOG(ERROR) << "GetStatus request failed with error: " << error->ToString();
   }
 
+    // Called when a response for SetReleaseTrack() is received.
+  void OnSetChannel(dbus::Response* response) {
+    if (!response) {
+      LOG(ERROR) << "Failed to request setting channel";
+      return;
+    }
+    VLOG(1) << "Succeeded to set channel";
+  }
+
+  // Called when a response for GetChannel() is received.
+  void OnGetChannel(const GetReleaseTrackCallback& callback,
+                    dbus::Response* response) {
+    if (!response) {
+      LOG(ERROR) << "Failed to request getting channel";
+      callback.Run("");
+      return;
+    }
+    dbus::MessageReader reader(response);
+    std::string channel;
+    if (!reader.PopString(&channel)) {
+      LOG(ERROR) << "Incorrect response: " << response->ToString();
+      callback.Run("");
+      return;
+    }
+    VLOG(1) << "The channel received: " << channel;
+    callback.Run(channel);
+  }
+
   // Called when a status update signal is received.
   void StatusUpdateReceived(dbus::Signal* signal) {
     VLOG(1) << "Status update signal received: " << signal->ToString();
     dbus::MessageReader reader(signal);
     int64 last_checked_time = 0;
     double progress = 0.0;
     std::string current_operation;
     std::string new_version;
     int64_t new_size = 0;
     if (!(reader.PopInt64(&last_checked_time) &&
@@ skipping 31 matching lines @@
   // 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<UpdateEngineClientImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(UpdateEngineClientImpl);
 };
 
 // The UpdateEngineClient implementation used on Linux desktop,
 // which does nothing.
 class UpdateEngineClientStubImpl : public UpdateEngineClient {
-  // UpdateEngineClient overrides.
+  // UpdateEngineClient implementation:
   virtual void AddObserver(Observer* observer) OVERRIDE {}
   virtual void RemoveObserver(Observer* observer) OVERRIDE {}
   virtual bool HasObserver(Observer* observer) OVERRIDE { return false; }
 
   virtual void RequestUpdateCheck(
       const UpdateCheckCallback& callback) OVERRIDE {
     callback.Run(UPDATE_RESULT_NOTIMPLEMENTED);
   }
   virtual void RebootAfterUpdate() OVERRIDE {}
   virtual void SetReleaseTrack(const std::string& track) OVERRIDE {}
   virtual void GetReleaseTrack(
       const GetReleaseTrackCallback& callback) OVERRIDE {
     callback.Run("beta-channel");
   }
   virtual Status GetLastStatus() OVERRIDE { return Status(); }
+  virtual void SetChannel(const std::string& target_channel,
+                          bool is_powerwash_allowed) OVERRIDE {
+    LOG(INFO) << "Requesting to set channel: "
+              << "target_channel=" << target_channel << ", "
+              << "is_powerwash_allowed=" << is_powerwash_allowed;
+  }
+  virtual void GetChannel(bool get_current_channel,
+                          const GetChannelCallback& callback) OVERRIDE {
+    LOG(INFO) << "Requesting to get channel, get_current_channel="
+              << get_current_channel;
+    callback.Run("beta-channel");
+  }
 };
 
 UpdateEngineClient::UpdateEngineClient() {
 }
 
 UpdateEngineClient::~UpdateEngineClient() {
 }
 
 // static
 UpdateEngineClient::UpdateCheckCallback
 UpdateEngineClient::EmptyUpdateCheckCallback() {
   return base::Bind(&EmptyUpdateCheckCallbackBody);
 }
 
 // static
 UpdateEngineClient* UpdateEngineClient::Create(
     DBusClientImplementationType type,
     dbus::Bus* bus) {
   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
     return new UpdateEngineClientImpl(bus);
   DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type);
   return new UpdateEngineClientStubImpl();
 }
 
 }  // namespace chromeos