chromeos/dbus/image_burner_client.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chromeos/dbus/image_burner_client.h"
   6
   7 #include "base/bind.h"
   8 #include "base/compiler_specific.h"
   9 #include "chromeos/dbus/fake_image_burner_client.h"
  10 #include "dbus/bus.h"
  11 #include "dbus/message.h"
  12 #include "dbus/object_path.h"
  13 #include "dbus/object_proxy.h"
  14 #include "third_party/cros_system_api/dbus/service_constants.h"
  15
  16 namespace chromeos {
  17
  18 namespace {
  19
  20 // The ImageBurnerClient implementation.
  21 class ImageBurnerClientImpl : public ImageBurnerClient {
  22  public:
  23   explicit ImageBurnerClientImpl(dbus::Bus* bus)
  24       : proxy_(NULL),
  25         weak_ptr_factory_(this) {
  26     proxy_ = bus->GetObjectProxy(
  27         imageburn::kImageBurnServiceName,
  28         dbus::ObjectPath(imageburn::kImageBurnServicePath));
  29     proxy_->ConnectToSignal(
  30         imageburn::kImageBurnServiceInterface,
  31         imageburn::kSignalBurnFinishedName,
  32         base::Bind(&ImageBurnerClientImpl::OnBurnFinished,
  33                    weak_ptr_factory_.GetWeakPtr()),
  34         base::Bind(&ImageBurnerClientImpl::OnSignalConnected,
  35                    weak_ptr_factory_.GetWeakPtr()));
  36     proxy_->ConnectToSignal(
  37         imageburn::kImageBurnServiceInterface,
  38         imageburn::kSignalBurnUpdateName,
  39         base::Bind(&ImageBurnerClientImpl::OnBurnProgressUpdate,
  40                    weak_ptr_factory_.GetWeakPtr()),
  41         base::Bind(&ImageBurnerClientImpl::OnSignalConnected,
  42                    weak_ptr_factory_.GetWeakPtr()));
  43   }
  44   virtual ~ImageBurnerClientImpl() {}
  45
  46   // ImageBurnerClient override.
  47   virtual void BurnImage(const std::string& from_path,
  48                          const std::string& to_path,
  49                          const ErrorCallback& error_callback) OVERRIDE {
  50     dbus::MethodCall method_call(imageburn::kImageBurnServiceInterface,
  51                                  imageburn::kBurnImage);
  52     dbus::MessageWriter writer(&method_call);
  53     writer.AppendString(from_path);
  54     writer.AppendString(to_path);
  55     proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
  56                        base::Bind(&ImageBurnerClientImpl::OnBurnImage,
  57                                   weak_ptr_factory_.GetWeakPtr(),
  58                                   error_callback));
  59   }
  60
  61   // ImageBurnerClient override.
  62   virtual void SetEventHandlers(
  63       const BurnFinishedHandler& burn_finished_handler,
  64       const BurnProgressUpdateHandler& burn_progress_update_handler) OVERRIDE {
  65     burn_finished_handler_ = burn_finished_handler;
  66     burn_progress_update_handler_ = burn_progress_update_handler;
  67   }
  68
  69   // ImageBurnerClient override.
  70   virtual void ResetEventHandlers() OVERRIDE {
  71     burn_finished_handler_.Reset();
  72     burn_progress_update_handler_.Reset();
  73   }
  74
  75  private:
  76   // Called when a response for BurnImage is received
  77   void OnBurnImage(ErrorCallback error_callback, dbus::Response* response) {
  78     if (!response) {
  79       error_callback.Run();
  80       return;
  81     }
  82   }
  83
  84   // Handles burn_finished signal and calls |handler|.
  85   void OnBurnFinished(dbus::Signal* signal) {
  86     dbus::MessageReader reader(signal);
  87     std::string target_path;
  88     bool success;
  89     std::string error;
  90     if (!reader.PopString(&target_path) ||
  91         !reader.PopBool(&success) ||
  92         !reader.PopString(&error)) {
  93       LOG(ERROR) << "Invalid signal: " << signal->ToString();
  94       return;
  95     }
  96     if (!burn_finished_handler_.is_null())
  97       burn_finished_handler_.Run(target_path, success, error);
  98   }
  99
 100   // Handles burn_progress_udpate signal and calls |handler|.
 101   void OnBurnProgressUpdate(dbus::Signal* signal) {
 102     dbus::MessageReader reader(signal);
 103     std::string target_path;
 104     int64 num_bytes_burnt;
 105     int64 total_size;
 106     if (!reader.PopString(&target_path) ||
 107         !reader.PopInt64(&num_bytes_burnt) ||
 108         !reader.PopInt64(&total_size)) {
 109       LOG(ERROR) << "Invalid signal: " << signal->ToString();
 110       return;
 111     }
 112     if (!burn_progress_update_handler_.is_null())
 113       burn_progress_update_handler_.Run(target_path, num_bytes_burnt,
 114                                         total_size);
 115   }
 116
 117   // Handles the result of signal connection setup.
 118   void OnSignalConnected(const std::string& interface,
 119                          const std::string& signal,
 120                          bool succeeded) {
 121     LOG_IF(ERROR, !succeeded) << "Connect to " << interface << " " <<
 122         signal << " failed.";
 123   }
 124
 125   dbus::ObjectProxy* proxy_;
 126   BurnFinishedHandler burn_finished_handler_;
 127   BurnProgressUpdateHandler burn_progress_update_handler_;
 128
 129   // Note: This should remain the last member so it'll be destroyed and
 130   // invalidate its weak pointers before any other members are destroyed.
 131   base::WeakPtrFactory<ImageBurnerClientImpl> weak_ptr_factory_;
 132
 133   DISALLOW_COPY_AND_ASSIGN(ImageBurnerClientImpl);
 134 };
 135
 136 }  // namespace
 137
 138 ImageBurnerClient::ImageBurnerClient() {
 139 }
 140
 141 ImageBurnerClient::~ImageBurnerClient() {
 142 }
 143
 144 // static
 145 ImageBurnerClient* ImageBurnerClient::Create(DBusClientImplementationType type,
 146                                              dbus::Bus* bus) {
 147   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
 148     return new ImageBurnerClientImpl(bus);
 149   DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type);
 150   return new FakeImageBurnerClient();
 151 }
 152
 153 }  // namespace chromeos