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/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 kGetManagedPropertiesResultFunction[] =
     "options.internet.DetailsInternetPage.getManagedPropertiesResult";
 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
@@ skipping 33 matching lines @@
 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 kNetworkInfoKeyServicePath[] = "servicePath";
 const char kTagErrorMessage[] = "errorMessage";
 const char kTagShowViewAccountButton[] = "showViewAccountButton";
+const char kTagVPNProviderID[] = "VPNProviderID";
+
+// ID used for the built-in OpenVPN/L2TP VPN provider. This must be kept in sync
+// with chrome/browser/resources/options/chromeos/vpn_providers.js.
+const char kBuiltInVPNProviderID[] = "built-in";

[michaelpg, 2015/03/16 05:45:20]

nit: make this a @const in vpn_providers.js and add a similar comment there

[bartfab (slow), 2015/03/16 10:04:51]

Done.

 
 void ShillError(const std::string& function,
                 const std::string& error_name,
                 scoped_ptr<base::DictionaryValue> error_data) {
   // UpdateConnectionData may send requests for stale services; ignore
   // these errors.
   if (function == "UpdateConnectionData" &&
       error_name == network_handler::kDBusFailedError)
     return;
   NET_LOG_ERROR("Shill Error from InternetOptionsHandler: " + error_name,
@@ skipping 13 matching lines @@
     const PrefService* profile_prefs) {
   scoped_ptr<base::DictionaryValue> network_info =
       network_util::TranslateNetworkStateToONC(network);
 
   bool has_policy = onc::HasPolicyForNetwork(
       profile_prefs, g_browser_process->local_state(), *network);
   network_info->SetBoolean(kNetworkInfoKeyPolicyManaged, has_policy);
 
   network_info->SetString(kNetworkInfoKeyServicePath, network->path());
 
+  if (network->type() == shill::kTypeVPN) {
+    std::string provider_id = network->vpn_provider_extension_id();
+    if (provider_id.empty())
+      provider_id = kBuiltInVPNProviderID;
+    network_info->SetString(kTagVPNProviderID, provider_id);
+  }

[stevenjb, 2015/03/15 17:00:08]

This should be done in network_state.cc, not here, since this is going away, but
I guess I can do that when I deprecate this.

(What we really want is to do this when we translate NetworkState to ONC and use
an ONC constant instead of 'built-in'.)

[bartfab (slow), 2015/03/16 10:04:51]

Fully ack. My goal was to prepare things so that we can switch over in two
steps:
1) Replace |kTagVPNProviderID| with a real ONC property.
2) Populate the property in network_state.cc instead of here.

+
   return network_info.release();
 }
 
 bool ShowViewAccountButton(const NetworkState* cellular) {
   if (cellular->activation_state() != shill::kActivationStateActivating &&
       cellular->activation_state() != shill::kActivationStateActivated)
     return false;
 
   const DeviceState* device =
       NetworkHandler::Get()->network_state_handler()->GetDeviceState(
@@ skipping 25 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);

[michaelpg, 2015/03/16 05:45:20]

nit: remove extra indentation

[bartfab (slow), 2015/03/16 10:04:51]

Done.

+}
+
+Profile* GetProfileForPrimaryUser() {
+  return chromeos::ProfileHelper::Get()->GetProfileByUser(
+      user_manager::UserManager::Get()->GetPrimaryUser());
+}
+
+extensions::ExtensionRegistry* GetExtensionRegistryForPrimaryUser() {
+  return extensions::ExtensionRegistry::Get(GetProfileForPrimaryUser());
+}
+
 }  // 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,
@@ skipping 19 matching lines @@
       base::Bind(&InternetOptionsHandler::GetManagedPropertiesCallback,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(kStartConnectMessage,
       base::Bind(&InternetOptionsHandler::StartConnectCallback,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(kSetPropertiesMessage,
       base::Bind(&InternetOptionsHandler::SetPropertiesCallback,
                  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 service_path;
   if (args->GetSize() != 1 || !args->GetString(0, &service_path)) {
     NOTREACHED();
     return;
   }
   ui::NetworkConnect::Get()->ShowMobileSetup(service_path);
@@ skipping 98 matching lines @@
   std::string service_path;
   if (!args->GetString(0, &service_path)) {
     NOTREACHED();
     return;
   }
   ui::NetworkConnect::Get()->ConnectToNetwork(service_path);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
+void InternetOptionsHandler::UpdateVPNProviders() {
+  extensions::ExtensionRegistry* const registry =
+      GetExtensionRegistryForPrimaryUser();
+
+  base::DictionaryValue vpn_providers;
+  const extensions::ExtensionSet& extensions = registry->enabled_extensions();
+  for (const auto& extension : extensions) {
+    if (IsVPNProvider(extension.get()))
+      vpn_providers.SetString(extension->id(), extension->name());
+  }
+  // Add the built-in OpenVPN/L2TP provider.
+  vpn_providers.SetString(
+      kBuiltInVPNProviderID,
+      l10n_util::GetStringUTF8(IDS_NETWORK_VPN_BUILT_IN_PROVIDER));
+
+  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 17 matching lines @@
     // Add a Chrome specific translated error message. TODO(stevenjb): Figure
     // out a more robust way to track errors. Service.Error is transient so we
     // use NetworkState.error() which accurately tracks the "last" error.
     dictionary->SetString(kTagErrorMessage,
                           ui::NetworkConnect::Get()->GetShillErrorString(
                               network->error(), service_path));
     // Add additional non-ONC cellular properties to inform the UI.
     if (network->type() == shill::kTypeCellular) {
       dictionary->SetBoolean(kTagShowViewAccountButton,
                              ShowViewAccountButton(network));
+    } else if (network->type() == shill::kTypeVPN) {
+      std::string provider_id = network->vpn_provider_extension_id();
+      if (provider_id.empty())
+        provider_id = kBuiltInVPNProviderID;
+      dictionary->SetString(kTagVPNProviderID, provider_id);
     }
   }
   web_ui()->CallJavascriptFunction(js_callback_function, *dictionary);
 }
 
 void InternetOptionsHandler::UpdateCarrier() {
   web_ui()->CallJavascriptFunction(kUpdateCarrierFunction);
 }
 
 void InternetOptionsHandler::DeviceListChanged() {
@@ skipping 78 matching lines @@
     LOG(ERROR) << "Unsupported type for AddConnection";
   }
 }
 
 void InternetOptionsHandler::ConfigureNetwork(const base::ListValue* args) {
   std::string service_path;
   if (args->GetSize() != 1 || !args->GetString(0, &service_path)) {
     NOTREACHED();
     return;
   }
+
+  const NetworkState* network = GetNetworkState(service_path);
+  if (!network)
+    return;
+
+  if (network->type() == shill::kTypeVPN &&
+      !network->vpn_provider_extension_id().empty()) {
+    // Request that the third-party VPN provider used by the |network| show a
+    // configuration dialog for it.
+    VpnServiceFactory::GetForBrowserContext(GetProfileForPrimaryUser())->
+        SendShowConfigureDialogToExtension(
+            network->vpn_provider_extension_id(), network->name());
+    return;
+  }
+
   NetworkConfigView::Show(service_path, GetNativeWindow());
 }
 
 void InternetOptionsHandler::ActivateNetwork(const base::ListValue* args) {
   std::string service_path;
   if (args->GetSize() != 1 || !args->GetString(0, &service_path)) {
     NOTREACHED();
     return;
   }
   ui::NetworkConnect::Get()->ActivateCellular(service_path);
@@ skipping 105 matching lines @@
   dictionary->SetBoolean(
       kTagWimaxAvailable,
       handler->IsTechnologyAvailable(NetworkTypePattern::Wimax()));
   dictionary->SetBoolean(
       kTagWimaxEnabled,
       handler->IsTechnologyEnabled(NetworkTypePattern::Wimax()));
 }
 
 }  // namespace options
 }  // namespace chromeos