chromeos: Change all clients of UpdateLibrary to use UpdateEngineClient.

chrome/browser/ui/webui/options/chromeos/about_page_handler.cc

 // Copyright (c) 2011 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 "chrome/browser/ui/webui/options/chromeos/about_page_handler.h"
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/i18n/time_formatting.h"
 #include "base/string16.h"
 #include "base/string_number_conversions.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
-#include "chrome/browser/chromeos/cros/cros_library.h"
-#include "chrome/browser/chromeos/cros/update_library.h"
 #include "chrome/browser/chromeos/dbus/dbus_thread_manager.h"
 #include "chrome/browser/chromeos/dbus/power_manager_client.h"
+#include "chrome/browser/chromeos/dbus/update_engine_client.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/browser/chromeos/login/wizard_controller.h"
 #include "chrome/browser/chromeos/user_cros_settings_provider.h"
 #include "chrome/browser/google/google_util.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/common/content_client.h"
 #include "googleurl/src/gurl.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
@@ skipping 24 matching lines @@
                            size_t end) {
   DCHECK(end > start);
   return text.substr(start, end - start);
 }
 
 }  // namespace
 
 namespace chromeos {
 
 class AboutPageHandler::UpdateObserver
-    : public UpdateLibrary::Observer {
+    : public UpdateEngineClient::Observer {
  public:
   explicit UpdateObserver(AboutPageHandler* handler) : page_handler_(handler) {}
   virtual ~UpdateObserver() {}
 
   AboutPageHandler* page_handler() const { return page_handler_; }
 
  private:
-  virtual void UpdateStatusChanged(const UpdateLibrary::Status& status) {
+  virtual void UpdateStatusChanged(
+      const UpdateEngineClient::Status& status) OVERRIDE {
     page_handler_->UpdateStatus(status);
   }
 
   AboutPageHandler* page_handler_;
 
   DISALLOW_COPY_AND_ASSIGN(UpdateObserver);
 };
 
 AboutPageHandler::AboutPageHandler()
     : CrosOptionsPageUIHandler(
           new UserCrosSettingsProvider),
       progress_(-1),
       sticky_(false),
       started_(false)
 {}
 
 AboutPageHandler::~AboutPageHandler() {
   if (update_observer_.get()) {
-    CrosLibrary::Get()->GetUpdateLibrary()->
+    DBusThreadManager::Get()->GetUpdateEngineClient()->
         RemoveObserver(update_observer_.get());
   }
 }
 
 void AboutPageHandler::GetLocalizedValues(DictionaryValue* localized_strings) {
   DCHECK(localized_strings);
 
   static OptionsStringResource resources[] = {
     { "firmware", IDS_ABOUT_PAGE_FIRMWARE },
     { "product", IDS_PRODUCT_OS_NAME },
@@ skipping 146 matching lines @@
 void AboutPageHandler::PageReady(const ListValue* args) {
   // Version information is loaded from a callback
   loader_.GetVersion(&consumer_,
                      base::Bind(&AboutPageHandler::OnOSVersion,
                                 base::Unretained(this)),
                      VersionLoader::VERSION_FULL);
   loader_.GetFirmware(&consumer_,
                       base::Bind(&AboutPageHandler::OnOSFirmware,
                                  base::Unretained(this)));
 
-  UpdateLibrary* update_library =
-      CrosLibrary::Get()->GetUpdateLibrary();
+  UpdateEngineClient* update_engine_client =
+      DBusThreadManager::Get()->GetUpdateEngineClient();
 
   update_observer_.reset(new UpdateObserver(this));
-  update_library->AddObserver(update_observer_.get());
+  update_engine_client->AddObserver(update_observer_.get());
 
   // Update the WebUI page with the current status. See comments below.
-  UpdateStatus(update_library->status());
+  UpdateStatus(update_engine_client->GetLastStatus());
 
   // Initiate update check. UpdateStatus() below will be called when we
   // get update status via update_observer_. If the update has been
   // already complete, update_observer_ won't receive a notification.
   // This is why we manually update the WebUI page above.
   CheckNow(NULL);
 
   // Request the channel information. Use the observer to track the about
   // page handler and ensure it does not get deleted before the callback.
-  update_library->GetReleaseTrack(UpdateSelectedChannel,
-                                  update_observer_.get());
+  update_engine_client->GetReleaseTrack(
+      base::Bind(UpdateSelectedChannel, update_observer_.get()));
 }
 
 void AboutPageHandler::SetReleaseTrack(const ListValue* args) {
   if (!UserManager::Get()->current_user_is_owner()) {
     LOG(WARNING) << "Non-owner tried to change release track.";
     return;
   }
   const std::string channel = UTF16ToUTF8(ExtractStringValue(args));
-  CrosLibrary::Get()->GetUpdateLibrary()->SetReleaseTrack(channel);
+  DBusThreadManager::Get()->GetUpdateEngineClient()->SetReleaseTrack(channel);
 }
 
 void AboutPageHandler::CheckNow(const ListValue* args) {
   // Make sure that libcros is loaded and OOBE is complete.
   if (!WizardController::default_controller() ||
       WizardController::IsDeviceRegistered()) {
-    CrosLibrary::Get()->GetUpdateLibrary()->
-        RequestUpdateCheck(NULL,   // no callback
-                           NULL);  // no userdata
+    DBusThreadManager::Get()->GetUpdateEngineClient()->
+        RequestUpdateCheck(UpdateEngineClient::EmptyUpdateCheckCallback());
   }
 }
 
 void AboutPageHandler::RestartNow(const ListValue* args) {
   DBusThreadManager::Get()->GetPowerManagerClient()->RequestRestart();
 }
 
 void AboutPageHandler::UpdateStatus(
-    const UpdateLibrary::Status& status) {
+    const UpdateEngineClient::Status& status) {
   string16 message;
   std::string image = "up-to-date";
   bool enabled = false;
 
   switch (status.status) {
-    case UPDATE_STATUS_IDLE:
+    case UpdateEngineClient::UPDATE_STATUS_IDLE:
       if (!sticky_) {
         message = l10n_util::GetStringFUTF16(IDS_UPGRADE_ALREADY_UP_TO_DATE,
             l10n_util::GetStringUTF16(IDS_PRODUCT_OS_NAME));
         enabled = true;
       }
       break;
-    case UPDATE_STATUS_CHECKING_FOR_UPDATE:
+    case UpdateEngineClient::UPDATE_STATUS_CHECKING_FOR_UPDATE:
       message = l10n_util::GetStringUTF16(IDS_UPGRADE_CHECK_STARTED);
       sticky_ = false;
       break;
-    case UPDATE_STATUS_UPDATE_AVAILABLE:
+    case UpdateEngineClient::UPDATE_STATUS_UPDATE_AVAILABLE:
       message = l10n_util::GetStringUTF16(IDS_UPDATE_AVAILABLE);
       started_ = true;
       break;
-    case UPDATE_STATUS_DOWNLOADING:
+    case UpdateEngineClient::UPDATE_STATUS_DOWNLOADING:
     {
       int progress = static_cast<int>(status.download_progress * 100.0);
       if (progress != progress_) {
         progress_ = progress;
         message = l10n_util::GetStringFUTF16Int(IDS_UPDATE_DOWNLOADING,
                                                 progress_);
       }
       started_ = true;
     }
       break;
-    case UPDATE_STATUS_VERIFYING:
+    case UpdateEngineClient::UPDATE_STATUS_VERIFYING:
       message = l10n_util::GetStringUTF16(IDS_UPDATE_VERIFYING);
       started_ = true;
       break;
-    case UPDATE_STATUS_FINALIZING:
+    case UpdateEngineClient::UPDATE_STATUS_FINALIZING:
       message = l10n_util::GetStringUTF16(IDS_UPDATE_FINALIZING);
       started_ = true;
       break;
-    case UPDATE_STATUS_UPDATED_NEED_REBOOT:
+    case UpdateEngineClient::UPDATE_STATUS_UPDATED_NEED_REBOOT:
       message = l10n_util::GetStringUTF16(IDS_UPDATE_COMPLETED);
       image = "available";
       sticky_ = true;
       break;
     default:
-    // case UPDATE_STATUS_ERROR:
-    // case UPDATE_STATUS_REPORTING_ERROR_EVENT:
+    // case UpdateEngineClient::UPDATE_STATUS_ERROR:
+    // case UpdateEngineClient::UPDATE_STATUS_REPORTING_ERROR_EVENT:
 
     // The error is only displayed if we were able to determine an
     // update was available.
       if (started_) {
         message = l10n_util::GetStringUTF16(IDS_UPDATE_ERROR);
         image = "fail";
         enabled = true;
         sticky_ = true;
         started_ = false;
       }
       break;
   }
   if (message.size()) {
     scoped_ptr<Value> update_message(Value::CreateStringValue(message));
     // "Checking for update..." needs to be shown for a while, so users
     // can read it, hence insert delay for this.
     scoped_ptr<Value> insert_delay(Value::CreateBooleanValue(
-        status.status == UPDATE_STATUS_CHECKING_FOR_UPDATE));
+        status.status ==
+        UpdateEngineClient::UPDATE_STATUS_CHECKING_FOR_UPDATE));
     web_ui_->CallJavascriptFunction("AboutPage.updateStatusCallback",
                                     *update_message, *insert_delay);
 
     scoped_ptr<Value> enabled_value(Value::CreateBooleanValue(enabled));
     web_ui_->CallJavascriptFunction("AboutPage.updateEnableCallback",
                                     *enabled_value);
 
     scoped_ptr<Value> image_string(Value::CreateStringValue(image));
     web_ui_->CallJavascriptFunction("AboutPage.setUpdateImage",
                                     *image_string);
   }
   // We'll change the "Check For Update" button to "Restart" button.
-  if (status.status == UPDATE_STATUS_UPDATED_NEED_REBOOT) {
+  if (status.status == UpdateEngineClient::UPDATE_STATUS_UPDATED_NEED_REBOOT) {
     web_ui_->CallJavascriptFunction("AboutPage.changeToRestartButton");
   }
 }
 
 void AboutPageHandler::OnOSVersion(VersionLoader::Handle handle,
                                    std::string version) {
   if (version.size()) {
     scoped_ptr<Value> version_string(Value::CreateStringValue(version));
     web_ui_->CallJavascriptFunction("AboutPage.updateOSVersionCallback",
                                     *version_string);
   }
 }
 
 void AboutPageHandler::OnOSFirmware(VersionLoader::Handle handle,
                                     std::string firmware) {
   if (firmware.size()) {
     scoped_ptr<Value> firmware_string(Value::CreateStringValue(firmware));
     web_ui_->CallJavascriptFunction("AboutPage.updateOSFirmwareCallback",
                                     *firmware_string);
   }
 }
 
 // Callback from UpdateEngine with channel information.
 // static
-void AboutPageHandler::UpdateSelectedChannel(void* user_data,
-                                             const char* channel) {
-  if (!user_data || !channel) {
-    LOG(WARNING) << "UpdateSelectedChannel returned NULL.";
-    return;
-  }
-  UpdateObserver* observer = static_cast<UpdateObserver*>(user_data);
-  if (CrosLibrary::Get()->GetUpdateLibrary()->HasObserver(observer)) {
-    // If UpdateLibrary still has the observer, then the page handler is valid.
+void AboutPageHandler::UpdateSelectedChannel(UpdateObserver* observer,
+                                             const std::string& channel) {
+  if (DBusThreadManager::Get()->GetUpdateEngineClient()
+      ->HasObserver(observer)) {
+    // If UpdateEngineClient still has the observer, then the page handler
+    // is valid.
     AboutPageHandler* handler = observer->page_handler();
     scoped_ptr<Value> channel_string(Value::CreateStringValue(channel));
     handler->web_ui_->CallJavascriptFunction(
         "AboutPage.updateSelectedOptionCallback", *channel_string);
   }
 }
 
 } // namespace chromeos