Eliminate CrosLibrary::EnsureLoaded

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"
@@ skipping 30 matching lines @@
 #include "policy/policy_constants.h"
 #include "views/widget/widget.h"
 
 using chromeos::CrosLibrary;
 using chromeos::NetworkLibrary;
 using chromeos::UpdateLibrary;
 using chromeos::UserManager;
 
 namespace {
 
-bool EnsureCrosLibraryLoaded(AutomationProvider* provider,
-                             IPC::Message* reply_message) {
-  if (!CrosLibrary::Get()->EnsureLoaded()) {
-    AutomationJSONReply(provider, reply_message).SendError(
-        "Could not load cros library.");
-    return false;
-  }
-  return true;
-}
-
 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());
   return item;
 }
 
 base::Value* GetProxySetting(Browser* browser,
@@ skipping 205 matching lines @@
   new LoginObserver(controller, this, reply_message);
 
   // WebUI login.
   chromeos::WebUILoginDisplay* webui_login_display =
       static_cast<chromeos::WebUILoginDisplay*>(controller->login_display());
   webui_login_display->ShowSigninScreenForCreds(username, password);
 }
 
 void TestingAutomationProvider::LockScreen(DictionaryValue* args,
                                            IPC::Message* reply_message) {
-  if (!EnsureCrosLibraryLoaded(this, reply_message))
-    return;
-
   new ScreenLockUnlockObserver(this, reply_message, true);
   CrosLibrary::Get()->GetScreenLockLibrary()->
       NotifyScreenLockRequested();
 }
 
 void TestingAutomationProvider::UnlockScreen(DictionaryValue* args,
                                              IPC::Message* reply_message) {
   std::string password;
   if (!args->GetString("password", &password)) {
     AutomationJSONReply(this, reply_message).SendError(
@@ skipping 28 matching lines @@
   }
 
   // Send success before stopping session because if we're a child of
   // session manager then we'll die when the session is stopped.
   reply.SendSuccess(NULL);
   screen_locker->Signout();
 }
 
 void TestingAutomationProvider::GetBatteryInfo(DictionaryValue* args,
                                                IPC::Message* reply_message) {
-  if (!EnsureCrosLibraryLoaded(this, reply_message))
-    return;
-
   scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
 
   return_value->SetBoolean("battery_is_present",
                            power_status.battery_is_present);
   return_value->SetBoolean("line_power_on", power_status.line_power_on);
   if (power_status.battery_is_present) {
     return_value->SetBoolean("battery_fully_charged",
                              power_status.battery_is_full);
     return_value->SetDouble("battery_percentage",
                             power_status.battery_percentage);
     if (power_status.line_power_on) {
       int64 time = power_status.battery_seconds_to_full;
       if (time > 0 || power_status.battery_is_full)
         return_value->SetInteger("battery_seconds_to_full", time);
     } else {
       int64 time = power_status.battery_seconds_to_empty;
       if (time > 0)
         return_value->SetInteger("battery_seconds_to_empty", time);
     }
   }
 
   AutomationJSONReply(this, reply_message).SendSuccess(return_value.get());
 }
 
 void TestingAutomationProvider::GetNetworkInfo(DictionaryValue* args,
                                                IPC::Message* reply_message) {
-  if (!EnsureCrosLibraryLoaded(this, reply_message))
-    return;
-
   scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
   NetworkLibrary* network_library = CrosLibrary::Get()->GetNetworkLibrary();
 
   return_value->SetBoolean("offline_mode",
                            net::NetworkChangeNotifier::IsOffline());
 
   // IP address.
   return_value->SetString("ip_address", network_library->IPAddress());
 
   // Currently connected networks.
@@ skipping 83 matching lines @@
       const chromeos::WifiNetwork* wifi = *iter;
       items->Append(base::Value::CreateStringValue(wifi->service_path()));
   }
   return_value->Set("remembered_wifi", items);
 
   AutomationJSONReply(this, reply_message).SendSuccess(return_value.get());
 }
 
 void TestingAutomationProvider::NetworkScan(DictionaryValue* args,
                                             IPC::Message* reply_message) {
-  if (!EnsureCrosLibraryLoaded(this, reply_message))
-    return;
-
   NetworkLibrary* network_library = CrosLibrary::Get()->GetNetworkLibrary();
   network_library->RequestNetworkScan();
 
   // Set up an observer (it will delete itself).
   new NetworkScanObserver(this, reply_message);
 }
 
 void TestingAutomationProvider::ToggleNetworkDevice(
     DictionaryValue* args, IPC::Message* reply_message) {
-  if (!EnsureCrosLibraryLoaded(this, reply_message))
-    return;
-
   AutomationJSONReply reply(this, reply_message);
   std::string device;
   bool enable;
   if (!args->GetString("device", &device) ||
       !args->GetBoolean("enable", &enable)) {
     reply.SendError("Invalid or missing args.");
     return;
   }
 
   // Set up an observer (it will delete itself).
@@ skipping 47 matching lines @@
   setting_path.append(key);
 
   // ProxyCrosSettingsProvider will own the Value* passed to Set().
   chromeos::proxy_cros_settings_parser::SetProxyPrefValue(
       browser->profile(), setting_path, value);
   reply.SendSuccess(NULL);
 }
 
 void TestingAutomationProvider::ConnectToCellularNetwork(
     DictionaryValue* args, IPC::Message* reply_message) {
-  if (!EnsureCrosLibraryLoaded(this, reply_message))
-    return;
-
   std::string service_path;
   if (!args->GetString("service_path", &service_path)) {
     AutomationJSONReply(this, reply_message).SendError(
         "Invalid or missing args.");
     return;
   }
 
   NetworkLibrary* network_library = CrosLibrary::Get()->GetNetworkLibrary();
   chromeos::CellularNetwork* cellular =
       network_library->FindCellularNetworkByPath(service_path);
   if (!cellular) {
     AutomationJSONReply(this, reply_message).SendError(
         "No network found with specified service path.");
     return;
   }
 
   // Set up an observer (it will delete itself).
   new ServicePathConnectObserver(this, reply_message, service_path);
 
   network_library->ConnectToCellularNetwork(cellular);
   network_library->RequestNetworkScan();
 }
 
 void TestingAutomationProvider::DisconnectFromCellularNetwork(
     DictionaryValue* args, IPC::Message* reply_message) {
-  if (!EnsureCrosLibraryLoaded(this, reply_message))
-    return;
-
   NetworkLibrary* network_library = CrosLibrary::Get()->GetNetworkLibrary();
   const chromeos::CellularNetwork* cellular =
         network_library->cellular_network();
   if (!cellular) {
     AutomationJSONReply(this, reply_message).SendError(
         "Not connected to any cellular network.");
     return;
   }
 
   // Set up an observer (it will delete itself).
   new NetworkDisconnectObserver(this, reply_message, cellular->service_path());
 
   network_library->DisconnectFromNetwork(cellular);
 }
 
 void TestingAutomationProvider::ConnectToWifiNetwork(
     DictionaryValue* args, IPC::Message* reply_message) {
-  if (!EnsureCrosLibraryLoaded(this, reply_message))
-    return;
-
   AutomationJSONReply reply(this, reply_message);
   std::string service_path, password;
   bool shared;
   if (!args->GetString("service_path", &service_path) ||
       !args->GetString("password", &password) ||
       !args->GetBoolean("shared", &shared)) {
     reply.SendError("Invalid or missing args.");
     return;
   }
 
@@ skipping 14 matching lines @@
 
   // Set up an observer (it will delete itself).
   new ServicePathConnectObserver(this, reply_message, service_path);
 
   network_library->ConnectToWifiNetwork(wifi, shared);
   network_library->RequestNetworkScan();
 }
 
 void TestingAutomationProvider::ForgetWifiNetwork(
     DictionaryValue* args, IPC::Message* reply_message) {
-  if (!EnsureCrosLibraryLoaded(this, reply_message))
-    return;
   std::string service_path;
   if (!args->GetString("service_path", &service_path)) {
     AutomationJSONReply(this, reply_message).SendError(
         "Invalid or missing args.");
     return;
   }
 
   CrosLibrary::Get()->GetNetworkLibrary()->ForgetNetwork(service_path);
   AutomationJSONReply(this, reply_message).SendSuccess(NULL);
 }
 
 void TestingAutomationProvider::ConnectToHiddenWifiNetwork(
     DictionaryValue* args, IPC::Message* reply_message) {
-  if (!EnsureCrosLibraryLoaded(this, reply_message))
-    return;
-
   std::string ssid, security, password;
   bool shared;
   if (!args->GetString("ssid", &ssid) ||
       !args->GetString("security", &security) ||
       !args->GetString("password", &password) ||
       !args->GetBoolean("shared", &shared)) {
     AutomationJSONReply(this, reply_message).SendError(
         "Invalid or missing args.");
     return;
   }
@@ skipping 73 matching lines @@
         save_credentials, shared);
   } else {
     network_library->ConnectToUnconfiguredWifiNetwork(
         ssid, connection_security, password, NULL,
         save_credentials, shared);
   }
 }
 
 void TestingAutomationProvider::DisconnectFromWifiNetwork(
     DictionaryValue* args, IPC::Message* reply_message) {
-  if (!EnsureCrosLibraryLoaded(this, reply_message))
-    return;
-
   AutomationJSONReply reply(this, reply_message);
   NetworkLibrary* network_library = CrosLibrary::Get()->GetNetworkLibrary();
   const chromeos::WifiNetwork* wifi = network_library->wifi_network();
   if (!wifi) {
     reply.SendError("Not connected to any wifi network.");
     return;
   }
 
   network_library->DisconnectFromNetwork(wifi);
   reply.SendSuccess(NULL);
 }
 
 void TestingAutomationProvider::AddPrivateNetwork(
     DictionaryValue* args, IPC::Message* reply_message) {
-  if (!EnsureCrosLibraryLoaded(this, reply_message))
-    return;
-
   std::string hostname, service_name, provider_type, key, cert_id, cert_nss,
       username, password;
   if (!args->GetString("hostname", &hostname) ||
       !args->GetString("service_name", &service_name) ||
       !args->GetString("provider_type", &provider_type) ||
       !args->GetString("username", &username) ||
       !args->GetString("password", &password)) {
     AutomationJSONReply(this, reply_message)
         .SendError("Invalid or missing args.");
     return;
@@ skipping 58 matching lines @@
         config_data);
   } else {
     AutomationJSONReply(this, reply_message)
         .SendError("Unsupported provider type.");
     return;
   }
 }
 
 void TestingAutomationProvider::ConnectToPrivateNetwork(
     DictionaryValue* args, IPC::Message* reply_message) {
-  if (!EnsureCrosLibraryLoaded(this, reply_message))
-    return;
-
   AutomationJSONReply reply(this, reply_message);
   std::string service_path;
   if (!args->GetString("service_path", &service_path)) {
     reply.SendError("Invalid or missing args.");
     return;
   }
 
   // Connect to a remembered VPN by its service_path. Valid service_paths
   // can be found in the dictionary returned by GetPrivateNetworkInfo.
   NetworkLibrary* network_library = CrosLibrary::Get()->GetNetworkLibrary();
   chromeos::VirtualNetwork* network =
       network_library->FindVirtualNetworkByPath(service_path);
   if (!network) {
     reply.SendError(StringPrintf("No virtual network found: %s",
                                  service_path.c_str()));
     return;
   }
   if (network->NeedMoreInfoToConnect()) {
     reply.SendError("Virtual network is missing info required to connect.");
     return;
   };
 
   // Set up an observer (it will delete itself).
   new VirtualConnectObserver(this, reply_message, network->name());
   network_library->ConnectToVirtualNetwork(network);
 }
 
 void TestingAutomationProvider::GetPrivateNetworkInfo(
     DictionaryValue* args, IPC::Message* reply_message) {
-  if (!EnsureCrosLibraryLoaded(this, reply_message))
-    return;
-
   scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
   NetworkLibrary* network_library = CrosLibrary::Get()->GetNetworkLibrary();
   const chromeos::VirtualNetworkVector& virtual_networks =
       network_library->virtual_networks();
 
   // Construct a dictionary of fields describing remembered VPNs. Also list
   // the currently active VPN, if any.
   if (network_library->virtual_network())
     return_value->SetString("connected",
                             network_library->virtual_network()->service_path());
@@ skipping 11 matching lines @@
     item->SetString("username", virt->username());
     item->SetString("password", virt->user_passphrase());
     return_value->Set(virt->service_path(), item);
   }
 
   AutomationJSONReply(this, reply_message).SendSuccess(return_value.get());
 }
 
 void TestingAutomationProvider::DisconnectFromPrivateNetwork(
     DictionaryValue* args, IPC::Message* reply_message) {
-  if (!EnsureCrosLibraryLoaded(this, reply_message))
-    return;
-
   AutomationJSONReply reply(this, reply_message);
   NetworkLibrary* network_library = CrosLibrary::Get()->GetNetworkLibrary();
   const chromeos::VirtualNetwork* virt = network_library->virtual_network();
   if (!virt) {
     reply.SendError("Not connected to any virtual network.");
     return;
   }
 
   network_library->DisconnectFromNetwork(virt);
   reply.SendSuccess(NULL);
@@ skipping 172 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) {
-  if (!EnsureCrosLibraryLoaded(this, reply_message))
-    return;
-
   UpdateLibrary* update_library = CrosLibrary::Get()->GetUpdateLibrary();
   AutomationJSONReply* reply = new AutomationJSONReply(this, reply_message);
   update_library->GetReleaseTrack(GetReleaseTrackCallback, reply);
 }
 
 void TestingAutomationProvider::UpdateCheck(
     DictionaryValue* args,
     IPC::Message* reply_message) {
-  if (!EnsureCrosLibraryLoaded(this, reply_message))
-    return;
-
   UpdateLibrary* update_library = CrosLibrary::Get()->GetUpdateLibrary();
   AutomationJSONReply* reply = new AutomationJSONReply(this, reply_message);
   update_library->RequestUpdateCheck(UpdateCheckCallback, reply);
 }
 
 void TestingAutomationProvider::SetReleaseTrack(DictionaryValue* args,
                                                 IPC::Message* reply_message) {
-  if (!EnsureCrosLibraryLoaded(this, reply_message))
-    return;
-
   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);
   reply.SendSuccess(NULL);
@@ skipping 61 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;
 }