chromeos: Change all clients of UpdateLibrary to use UpdateEngineClient.

chrome/browser/automation/testing_automation_provider_chromeos.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/automation/testing_automation_provider.h"
 
 #include "base/command_line.h"
 #include "base/i18n/time_formatting.h"
 #include "base/stringprintf.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/automation/automation_provider_json.h"
 #include "chrome/browser/automation/automation_provider_observers.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/audio_handler.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/cros/network_library.h"
 #include "chrome/browser/chromeos/cros/power_library.h"
 #include "chrome/browser/chromeos/cros/screen_lock_library.h"
-#include "chrome/browser/chromeos/cros/update_library.h"
+#include "chrome/browser/chromeos/dbus/dbus_thread_manager.h"
+#include "chrome/browser/chromeos/dbus/update_engine_client.h"
 #include "chrome/browser/chromeos/login/enrollment/enterprise_enrollment_screen.h"
 #include "chrome/browser/chromeos/login/existing_user_controller.h"
 #include "chrome/browser/chromeos/login/login_display.h"
 #include "chrome/browser/chromeos/login/login_display_host.h"
 #include "chrome/browser/chromeos/login/screen_locker.h"
 #include "chrome/browser/chromeos/login/webui_login_display.h"
 #include "chrome/browser/chromeos/login/wizard_controller.h"
 #include "chrome/browser/chromeos/options/take_photo_dialog.h"
 #include "chrome/browser/chromeos/proxy_cros_settings_parser.h"
 #include "chrome/browser/chromeos/system/timezone_settings.h"
 #include "chrome/browser/policy/browser_policy_connector.h"
 #include "chrome/browser/policy/cloud_policy_cache_base.h"
 #include "chrome/browser/policy/cloud_policy_data_store.h"
 #include "chrome/browser/policy/cloud_policy_subsystem.h"
 #include "chrome/browser/policy/enterprise_install_attributes.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/views/window.h"
 #include "chrome/common/pref_names.h"
 #include "net/base/network_change_notifier.h"
 #include "policy/policy_constants.h"
 #include "ui/views/widget/widget.h"
 
 using chromeos::CrosLibrary;
+using chromeos::DBusThreadManager;
 using chromeos::NetworkLibrary;
-using chromeos::UpdateLibrary;
+using chromeos::UpdateEngineClient;
 using chromeos::UserManager;
 
 namespace {
 
 DictionaryValue* GetNetworkInfoDict(const chromeos::Network* network) {
   DictionaryValue* item = new DictionaryValue;
   item->SetString("name", network->name());
   item->SetString("device_path", network->device_path());
   item->SetString("ip_address", network->ip_address());
   item->SetString("status", network->GetStateString());
@@ skipping 19 matching lines @@
       base::Value* value;
       bool found = setting_dict->Remove("value", &value);
       delete setting;
       if (found)
         return value;
     }
   }
   return NULL;
 }
 
-const char* UpdateStatusToString(chromeos::UpdateStatusOperation status) {
+const char* UpdateStatusToString(
+    UpdateEngineClient::UpdateStatusOperation status) {
   switch (status) {
-    case chromeos::UPDATE_STATUS_IDLE:
+    case UpdateEngineClient::UPDATE_STATUS_IDLE:
       return "idle";
-    case chromeos::UPDATE_STATUS_CHECKING_FOR_UPDATE:
+    case UpdateEngineClient::UPDATE_STATUS_CHECKING_FOR_UPDATE:
       return "checking for update";
-    case chromeos::UPDATE_STATUS_UPDATE_AVAILABLE:
+    case UpdateEngineClient::UPDATE_STATUS_UPDATE_AVAILABLE:
       return "update available";
-    case chromeos::UPDATE_STATUS_DOWNLOADING:
+    case UpdateEngineClient::UPDATE_STATUS_DOWNLOADING:
       return "downloading";
-    case chromeos::UPDATE_STATUS_VERIFYING:
+    case UpdateEngineClient::UPDATE_STATUS_VERIFYING:
       return "verifying";
-    case chromeos::UPDATE_STATUS_FINALIZING:
+    case UpdateEngineClient::UPDATE_STATUS_FINALIZING:
       return "finalizing";
-    case chromeos::UPDATE_STATUS_UPDATED_NEED_REBOOT:
+    case UpdateEngineClient::UPDATE_STATUS_UPDATED_NEED_REBOOT:
       return "updated need reboot";
-    case chromeos::UPDATE_STATUS_REPORTING_ERROR_EVENT:
+    case UpdateEngineClient::UPDATE_STATUS_REPORTING_ERROR_EVENT:
       return "reporting error event";
     default:
       return "unknown";
   }
 }
 
-void GetReleaseTrackCallback(void* user_data, const char* track) {
-  AutomationJSONReply* reply = static_cast<AutomationJSONReply*>(user_data);
-
-  if (track == NULL) {
+void GetReleaseTrackCallback(AutomationJSONReply* reply,
+                             const std::string& track) {
+  if (track.empty()) {
     reply->SendError("Unable to get release track.");
     delete reply;
     return;
   }
 
   scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
   return_value->SetString("release_track", track);
 
-  UpdateLibrary* update_library = CrosLibrary::Get()->GetUpdateLibrary();
-  const UpdateLibrary::Status& status = update_library->status();
-  chromeos::UpdateStatusOperation update_status = status.status;
+  const UpdateEngineClient::Status& status =
+      DBusThreadManager::Get()->GetUpdateEngineClient()->GetLastStatus();
+  UpdateEngineClient::UpdateStatusOperation update_status =
+      status.status;
   return_value->SetString("status", UpdateStatusToString(update_status));
-  if (update_status == chromeos::UPDATE_STATUS_DOWNLOADING)
+  if (update_status == UpdateEngineClient::UPDATE_STATUS_DOWNLOADING)
     return_value->SetDouble("download_progress", status.download_progress);
   if (status.last_checked_time > 0)
     return_value->SetInteger("last_checked_time", status.last_checked_time);
   if (status.new_size > 0)
     return_value->SetInteger("new_size", status.new_size);
 
   reply->SendSuccess(return_value.get());
   delete reply;
 }
 
-void UpdateCheckCallback(void* user_data, chromeos::UpdateResult result,
-                         const char* error_msg) {
-  AutomationJSONReply* reply = static_cast<AutomationJSONReply*>(user_data);
-  if (result == chromeos::UPDATE_RESULT_SUCCESS)
+void UpdateCheckCallback(AutomationJSONReply* reply,
+                         UpdateEngineClient::UpdateCheckResult result) {
+  if (result == UpdateEngineClient::UPDATE_RESULT_SUCCESS)
     reply->SendSuccess(NULL);
   else
-    reply->SendError(error_msg);
+    reply->SendError("update check failed");
   delete reply;
 }
 
 const std::string VPNProviderTypeToString(
     chromeos::ProviderType provider_type) {
   switch (provider_type) {
     case chromeos::PROVIDER_TYPE_L2TP_IPSEC_PSK:
       return std::string("L2TP_IPSEC_PSK");
     case chromeos::PROVIDER_TYPE_L2TP_IPSEC_USER_CERT:
       return std::string("L2TP_IPSEC_USER_CERT");
@@ skipping 892 matching lines @@
 
   icu::TimeZone* timezone =
       icu::TimeZone::createTimeZone(icu::UnicodeString::fromUTF8(timezone_id));
   chromeos::system::TimezoneSettings::GetInstance()->SetTimezone(*timezone);
   delete timezone;
   AutomationJSONReply(this, reply_message).SendSuccess(NULL);
 }
 
 void TestingAutomationProvider::GetUpdateInfo(DictionaryValue* args,
                                               IPC::Message* reply_message) {
-  UpdateLibrary* update_library = CrosLibrary::Get()->GetUpdateLibrary();
   AutomationJSONReply* reply = new AutomationJSONReply(this, reply_message);
-  update_library->GetReleaseTrack(GetReleaseTrackCallback, reply);
+  DBusThreadManager::Get()->GetUpdateEngineClient()
+      ->GetReleaseTrack(base::Bind(GetReleaseTrackCallback, reply));
 }
 
 void TestingAutomationProvider::UpdateCheck(
     DictionaryValue* args,
     IPC::Message* reply_message) {
-  UpdateLibrary* update_library = CrosLibrary::Get()->GetUpdateLibrary();
   AutomationJSONReply* reply = new AutomationJSONReply(this, reply_message);
-  update_library->RequestUpdateCheck(UpdateCheckCallback, reply);
+  DBusThreadManager::Get()->GetUpdateEngineClient()
+      ->RequestUpdateCheck(base::Bind(UpdateCheckCallback, reply));
 }
 
 void TestingAutomationProvider::SetReleaseTrack(DictionaryValue* args,
                                                 IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   std::string track;
   if (!args->GetString("track", &track)) {
     reply.SendError("Invalid or missing args.");
     return;
   }
 
-  UpdateLibrary* update_library = CrosLibrary::Get()->GetUpdateLibrary();
-  update_library->SetReleaseTrack(track);
+  DBusThreadManager::Get()->GetUpdateEngineClient()->SetReleaseTrack(track);
   reply.SendSuccess(NULL);
 }
 
 void TestingAutomationProvider::GetVolumeInfo(DictionaryValue* args,
                                               IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
   chromeos::AudioHandler* audio_handler = chromeos::AudioHandler::GetInstance();
   if (!audio_handler) {
     reply.SendError("AudioHandler not initialized.");
@@ skipping 52 matching lines @@
   views::Widget* window = browser::CreateViewsWindow(
       browser->window()->GetNativeHandle(), take_photo_dialog);
   window->SetAlwaysOnTop(true);
   window->Show();
 }
 
 void TestingAutomationProvider::PowerChanged(
     const chromeos::PowerSupplyStatus& status) {
   power_status = status;
 }