Add third-party VPN support to network details dialog

chrome/browser/ui/webui/options/chromeos/internet_options_handler.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 "chrome/browser/ui/webui/options/chromeos/internet_options_handler.h"
 
 #include <ctype.h>
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
+#include "base/memory/scoped_ptr.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/mobile_config.h"
 #include "chrome/browser/chromeos/net/onc_utils.h"
 #include "chrome/browser/chromeos/options/network_config_view.h"
 #include "chrome/browser/chromeos/options/network_property_ui_data.h"
+#include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/chromeos/sim_dialog_delegate.h"
 #include "chrome/browser/chromeos/ui/choose_mobile_network_dialog.h"
 #include "chrome/browser/chromeos/ui/mobile_config_ui.h"
 #include "chrome/browser/chromeos/ui_proxy_config_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/webui/chromeos/mobile_setup_dialog.h"
 #include "chrome/browser/ui/webui/options/chromeos/internet_options_handler_strings.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/login/login_state.h"
 #include "chromeos/network/device_state.h"
 #include "chromeos/network/managed_network_configuration_handler.h"
 #include "chromeos/network/network_connection_handler.h"
 #include "chromeos/network/network_device_handler.h"
 #include "chromeos/network/network_event_log.h"
 #include "chromeos/network/network_ip_config.h"
 #include "chromeos/network/network_profile.h"
 #include "chromeos/network/network_profile_handler.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/network/network_util.h"
 #include "chromeos/network/onc/onc_signature.h"
 #include "chromeos/network/onc/onc_translation_tables.h"
 #include "chromeos/network/onc/onc_translator.h"
 #include "chromeos/network/onc/onc_utils.h"
 #include "components/onc/onc_constants.h"
+#include "components/user_manager/user_manager.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_ui.h"
+#include "extensions/browser/api/vpn_provider/vpn_service.h"
+#include "extensions/browser/api/vpn_provider/vpn_service_factory.h"
+#include "extensions/browser/extension_registry.h"
+#include "extensions/common/extension.h"
+#include "extensions/common/extension_set.h"
+#include "extensions/common/permissions/api_permission.h"
+#include "extensions/common/permissions/permissions_data.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
+#include "ui/base/l10n/l10n_util.h"
 #include "ui/base/webui/web_ui_util.h"
 #include "ui/chromeos/network/network_connect.h"
+#include "ui/chromeos/strings/grit/ui_chromeos_strings.h"
 
 namespace chromeos {
 namespace options {
 
 namespace {
 
 // Keys for the initial "localized" dictionary values.
 const char kLoggedInAsOwnerKey[] = "loggedInAsOwner";
 const char kShowCarrierSelectKey[] = "showCarrierSelect";
 const char kNetworkDataKey[] = "networkData";
 
 // Keys for the network description dictionary passed to the web ui. Make sure
 // to keep the strings in sync with what the JavaScript side uses.
 const char kNetworkInfoKeyPolicyManaged[] = "policyManaged";
 
 // Functions we call in JavaScript.
+const char kSetVPNProvidersFunction[] = "options.VPNProviders.setProviders";
 const char kRefreshNetworkDataFunction[] =
     "options.network.NetworkList.refreshNetworkData";
 const char kUpdateConnectionDataFunction[] =
     "options.internet.DetailsInternetPage.updateConnectionData";
 const char kUpdateCarrierFunction[] =
     "options.internet.DetailsInternetPage.updateCarrier";
 
 // Setter methods called from JS that still need to be converted to match
 // networkingPrivate methods.
 const char kSetCarrierMessage[] = "setCarrier";
 const char kShowMorePlanInfoMessage[] = "showMorePlanInfo";
 const char kSimOperationMessage[] = "simOperation";
 
 // TODO(stevenjb): Replace these with the matching networkingPrivate methods.
 // crbug.com/279351.
 const char kStartConnectMessage[] = "startConnect";
 
 // TODO(stevenjb): Deprecate this once we handle events in the JS.
 const char kSetNetworkGuidMessage[] = "setNetworkGuid";
 
 // TODO(stevenjb): Add these to networkingPrivate.
 const char kRemoveNetworkMessage[] = "removeNetwork";
 
 // TODO(stevenjb): Deprecate these and integrate with settings Web UI.
 const char kAddConnectionMessage[] = "addConnection";
 const char kConfigureNetworkMessage[] = "configureNetwork";
 const char kActivateNetworkMessage[] = "activateNetwork";
 
+const char kLoadVPNProviders[] = "loadVPNProviders";
+
 // These are strings used to communicate with JavaScript.
 const char kTagCellularAvailable[] = "cellularAvailable";
 const char kTagCellularEnabled[] = "cellularEnabled";
 const char kTagCellularSimAbsent[] = "cellularSimAbsent";
 const char kTagCellularSimLockType[] = "cellularSimLockType";
 const char kTagCellularSupportsScan[] = "cellularSupportsScan";
 const char kTagRememberedList[] = "rememberedList";
 const char kTagSimOpChangePin[] = "changePin";
 const char kTagSimOpConfigure[] = "configure";
 const char kTagSimOpSetLocked[] = "setLocked";
 const char kTagSimOpSetUnlocked[] = "setUnlocked";
 const char kTagSimOpUnlock[] = "unlock";
+const char kTagVPNProviderName[] = "name";
+const char kTagVPNProviderExtensionID[] = "extensionID";
 const char kTagVpnList[] = "vpnList";
 const char kTagWifiAvailable[] = "wifiAvailable";
 const char kTagWifiEnabled[] = "wifiEnabled";
 const char kTagWimaxAvailable[] = "wimaxAvailable";
 const char kTagWimaxEnabled[] = "wimaxEnabled";
 const char kTagWiredList[] = "wiredList";
 const char kTagWirelessList[] = "wirelessList";
 
 // Pseudo-ONC chrome specific properties appended to the ONC dictionary.
 const char kTagShowViewAccountButton[] = "showViewAccountButton";
@@ skipping 73 matching lines @@
       device->properties().GetStringWithoutPathExpansion(shill::kMdnProperty,
                                                          &mdn);
     }
     if (mdn.empty())
       return false;
   }
 
   return true;
 }
 
+bool IsVPNProvider(const extensions::Extension* extension) {
+  return extension->permissions_data()->HasAPIPermission(
+      extensions::APIPermission::kVpnProvider);
+}
+
+Profile* GetProfileForPrimaryUser() {
+  return chromeos::ProfileHelper::Get()->GetProfileByUser(
+      user_manager::UserManager::Get()->GetPrimaryUser());
+}
+
+extensions::ExtensionRegistry* GetExtensionRegistryForPrimaryUser() {
+  return extensions::ExtensionRegistry::Get(GetProfileForPrimaryUser());
+}
+
+scoped_ptr<base::DictionaryValue> BuildVPNProviderDictionary(
+    const std::string& name,
+    const std::string& third_party_provider_extension_id) {
+  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue);
+  dict->SetString(kTagVPNProviderName, name);
+  if (!third_party_provider_extension_id.empty()) {
+    dict->SetString(kTagVPNProviderExtensionID,
+                    third_party_provider_extension_id);
+  }
+  return dict.Pass();
+}
+
 }  // namespace
 
 InternetOptionsHandler::InternetOptionsHandler()
     : weak_factory_(this) {
+  GetExtensionRegistryForPrimaryUser()->AddObserver(this);
   NetworkHandler::Get()->network_state_handler()->AddObserver(this, FROM_HERE);
 }
 
 InternetOptionsHandler::~InternetOptionsHandler() {
   if (NetworkHandler::IsInitialized()) {
     NetworkHandler::Get()->network_state_handler()->RemoveObserver(
         this, FROM_HERE);
   }
+  GetExtensionRegistryForPrimaryUser()->RemoveObserver(this);
 }
 
 void InternetOptionsHandler::GetLocalizedValues(
     base::DictionaryValue* localized_strings) {
   DCHECK(localized_strings);
   internet_options_strings::RegisterLocalizedStrings(localized_strings);
 
   // TODO(stevenjb): Find a better way to populate initial data before
   // InitializePage() gets called.
   std::string owner;
   chromeos::CrosSettings::Get()->GetString(chromeos::kDeviceOwner, &owner);
   bool logged_in_as_owner = LoginState::Get()->GetLoggedInUserType() ==
                             LoginState::LOGGED_IN_USER_OWNER;
   localized_strings->SetBoolean(kLoggedInAsOwnerKey, logged_in_as_owner);
   localized_strings->SetBoolean(
       kShowCarrierSelectKey, base::CommandLine::ForCurrentProcess()->HasSwitch(
                                  chromeos::switches::kEnableCarrierSwitching));
 
   base::DictionaryValue* network_dictionary = new base::DictionaryValue;
   FillNetworkInfo(network_dictionary);
   localized_strings->Set(kNetworkDataKey, network_dictionary);
 }
 
 void InternetOptionsHandler::InitializePage() {
+  UpdateVPNProviders();
   NetworkHandler::Get()->network_state_handler()->RequestScan();
   RefreshNetworkData();
 }
 
 void InternetOptionsHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback(kAddConnectionMessage,
       base::Bind(&InternetOptionsHandler::AddConnection,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(kRemoveNetworkMessage,
       base::Bind(&InternetOptionsHandler::RemoveNetwork,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(kConfigureNetworkMessage,
       base::Bind(&InternetOptionsHandler::ConfigureNetwork,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(kActivateNetworkMessage,
       base::Bind(&InternetOptionsHandler::ActivateNetwork,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(kShowMorePlanInfoMessage,
       base::Bind(&InternetOptionsHandler::ShowMorePlanInfoCallback,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(kSetCarrierMessage,
       base::Bind(&InternetOptionsHandler::SetCarrierCallback,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(kSimOperationMessage,
       base::Bind(&InternetOptionsHandler::SimOperationCallback,
                  base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
+      kLoadVPNProviders,
+      base::Bind(&InternetOptionsHandler::LoadVPNProvidersCallback,
+                 base::Unretained(this)));
 
   web_ui()->RegisterMessageCallback(kSetNetworkGuidMessage,
       base::Bind(&InternetOptionsHandler::SetNetworkGuidCallback,
                  base::Unretained(this)));
 
   // networkingPrivate methods
   web_ui()->RegisterMessageCallback(kStartConnectMessage,
       base::Bind(&InternetOptionsHandler::StartConnectCallback,
                  base::Unretained(this)));
 }
 
+void InternetOptionsHandler::OnExtensionLoaded(
+    content::BrowserContext* browser_context,
+    const extensions::Extension* extension) {
+  if (IsVPNProvider(extension))
+    UpdateVPNProviders();
+}
+
+void InternetOptionsHandler::OnExtensionUnloaded(
+    content::BrowserContext* browser_context,
+    const extensions::Extension* extension,
+    extensions::UnloadedExtensionInfo::Reason reason) {
+  if (IsVPNProvider(extension))
+    UpdateVPNProviders();
+}
+
+void InternetOptionsHandler::OnShutdown(
+    extensions::ExtensionRegistry* registry) {
+  registry->RemoveObserver(this);
+}
+
 void InternetOptionsHandler::ShowMorePlanInfoCallback(
     const base::ListValue* args) {
   if (!web_ui())
     return;
   std::string guid;
   if (args->GetSize() != 1 || !args->GetString(0, &guid)) {
     NOTREACHED();
     return;
   }
   std::string service_path = ServicePathFromGuid(guid);
@@ skipping 93 matching lines @@
     NOTREACHED();
     return;
   }
   std::string service_path = ServicePathFromGuid(guid);
   if (!service_path.empty())
     ui::NetworkConnect::Get()->ConnectToNetwork(service_path);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
+void InternetOptionsHandler::UpdateVPNProviders() {
+  extensions::ExtensionRegistry* const registry =
+      GetExtensionRegistryForPrimaryUser();
+
+  base::ListValue vpn_providers;
+  const extensions::ExtensionSet& extensions = registry->enabled_extensions();
+  for (const auto& extension : extensions) {
+    if (IsVPNProvider(extension.get())) {
+      vpn_providers.Append(BuildVPNProviderDictionary(
+                               extension->name(), extension->id()).release());
+    }
+  }
+  // Add the built-in OpenVPN/L2TP provider.
+  vpn_providers.Append(
+      BuildVPNProviderDictionary(
+          l10n_util::GetStringUTF8(IDS_NETWORK_VPN_BUILT_IN_PROVIDER),
+          std::string() /* third_party_provider_extension_id */).release());
+  web_ui()->CallJavascriptFunction(kSetVPNProvidersFunction, vpn_providers);
+}
+
 void InternetOptionsHandler::RefreshNetworkData() {
   base::DictionaryValue dictionary;
   FillNetworkInfo(&dictionary);
   web_ui()->CallJavascriptFunction(kRefreshNetworkDataFunction, dictionary);
 }
 
 void InternetOptionsHandler::UpdateConnectionData(
     const std::string& service_path) {
   NetworkHandler::Get()
       ->managed_network_configuration_handler()
@@ skipping 90 matching lines @@
     LOG(ERROR) << "Unsupported type for AddConnection";
   }
 }
 
 void InternetOptionsHandler::ConfigureNetwork(const base::ListValue* args) {
   std::string guid;
   if (args->GetSize() != 1 || !args->GetString(0, &guid)) {
     NOTREACHED();
     return;
   }
-  std::string service_path = ServicePathFromGuid(guid);
-  if (!service_path.empty())
-    NetworkConfigView::Show(service_path, GetNativeWindow());
+  const std::string service_path = ServicePathFromGuid(guid);
+  if (service_path.empty())
+    return;
+
+  const NetworkState* network = GetNetworkState(service_path);
+  if (!network)
+    return;
+
+  if (network->type() == shill::kTypeVPN &&
+      network->vpn_provider_type() == shill::kProviderThirdPartyVpn) {
+    // Request that the third-party VPN provider used by the |network| show a
+    // configuration dialog for it.
+    VpnServiceFactory::GetForBrowserContext(GetProfileForPrimaryUser())
+        ->SendShowConfigureDialogToExtension(
+            network->third_party_vpn_provider_extension_id(), network->name());
+    return;
+  }
+
+  NetworkConfigView::Show(service_path, GetNativeWindow());
 }
 
 void InternetOptionsHandler::ActivateNetwork(const base::ListValue* args) {
   std::string guid;
   if (args->GetSize() != 1 || !args->GetString(0, &guid)) {
     NOTREACHED();
     return;
   }
   std::string service_path = ServicePathFromGuid(guid);
   if (!service_path.empty())
     ui::NetworkConnect::Get()->ActivateCellular(service_path);
 }
 
 void InternetOptionsHandler::RemoveNetwork(const base::ListValue* args) {
   std::string guid;
   if (args->GetSize() != 1 || !args->GetString(0, &guid)) {
     NOTREACHED();
     return;
   }
   std::string service_path = ServicePathFromGuid(guid);
   if (service_path.empty())
     return;
   NetworkHandler::Get()
       ->managed_network_configuration_handler()
       ->RemoveConfiguration(service_path, base::Bind(&base::DoNothing),
                             base::Bind(&ShillError, "RemoveNetwork"));
 }
 
+void InternetOptionsHandler::LoadVPNProvidersCallback(
+    const base::ListValue* args) {
+  UpdateVPNProviders();
+}
+
 base::ListValue* InternetOptionsHandler::GetWiredList() {
   base::ListValue* list = new base::ListValue();
   const NetworkState* network = NetworkHandler::Get()->network_state_handler()->
       FirstNetworkByType(NetworkTypePattern::Ethernet());
   if (!network)
     return list;
   list->Append(BuildNetworkDictionary(network, GetPrefs()));
   return list;
 }
 
@@ skipping 81 matching lines @@
   dictionary->SetBoolean(
       kTagWimaxAvailable,
       handler->IsTechnologyAvailable(NetworkTypePattern::Wimax()));
   dictionary->SetBoolean(
       kTagWimaxEnabled,
       handler->IsTechnologyEnabled(NetworkTypePattern::Wimax()));
 }
 
 }  // namespace options
 }  // namespace chromeos