Add ash::VPNDelegate and Chrome OS implementation

chrome/browser/ui/ash/vpn_delegate_chromeos.cc

Index: chrome/browser/ui/ash/vpn_delegate_chromeos.cc
diff --git a/chrome/browser/ui/ash/vpn_delegate_chromeos.cc b/chrome/browser/ui/ash/vpn_delegate_chromeos.cc
new file mode 100644
index 0000000000000000000000000000000000000000..9bb952925be2505f96c9bee5a1ba3e1133372c9e
--- /dev/null
+++ b/chrome/browser/ui/ash/vpn_delegate_chromeos.cc
@@ -0,0 +1,155 @@
+// Copyright 2015 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/ash/vpn_delegate_chromeos.h"
+
+#include <string>
+
+#include "ash/shell.h"
+#include "ash/system/tray/system_tray_delegate.h"
+#include "base/logging.h"
+#include "chrome/browser/chrome_notification_types.h"
+#include "chrome/browser/chromeos/profiles/profile_helper.h"
+#include "chrome/browser/profiles/profile.h"
+#include "components/user_manager/user.h"
+#include "components/user_manager/user_manager.h"
+#include "content/public/browser/notification_service.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/chromeos/strings/grit/ui_chromeos_strings.h"
+
+namespace {
+
+bool IsVPNProvider(const extensions::Extension* extension) {
+  return extension->permissions_data()->HasAPIPermission(
+             extensions::APIPermission::kVpnProvider);
+}
+
+Profile* GetProfileForPrimaryUser() {
+  const user_manager::User* const primary_user =
+      user_manager::UserManager::Get()->GetPrimaryUser();
+  if (!primary_user)
+    return nullptr;
+
+  return chromeos::ProfileHelper::Get()->GetProfileByUser(primary_user);
+}
+
+}  // namespace
+
+VPNDelegateChromeOS::VPNDelegateChromeOS() {
+  if (user_manager::UserManager::Get()->GetPrimaryUser()) {
+    // If a user is logged in, start observing the primary user's extension
+    // registry immediately.
+    AttachToPrimaryUserExtensionRegistry();
+  } else {
+    // If no user is logged in, wait for the first user to log in and become the
+    // primary user.
+    registrar_.Add(this,
+                   chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED,
+                   content::NotificationService::AllSources());
+  }
+}
+
+VPNDelegateChromeOS::~VPNDelegateChromeOS() {
+  if (extension_registry_)
+    extension_registry_->RemoveObserver(this);
+}
+
+bool VPNDelegateChromeOS::HaveThirdPartyVPNProviders() const {
+  // If there are third-party VPN providers, the list will contain the built-in
+  // OpenVPN/L2TP provider and at least one more entry.
+  return vpn_providers_.size() > 1;
+}
+
+const std::vector<ash::VPNProvider>&
+VPNDelegateChromeOS::GetVPNProviders() const {
+  return vpn_providers_;
+}
+
+void VPNDelegateChromeOS::ShowAddPage(const std::string& id) {
+  if (id.empty()) {
+    // If |id| is an empty string, show the "add network" dialog for the
+    // built-in OpenVPN/L2TP provider.
+    ash::Shell::GetInstance()->system_tray_delegate()->ShowOtherNetworkDialog(
+        shill::kTypeVPN);
+    return;
+  }
+
+  Profile* const profile = GetProfileForPrimaryUser();
+  if (!profile)
+    return;
+
+  // Request that the third-party VPN provider identified by |id| show its "add
+  // network" dialog.
+  chromeos::VpnServiceFactory::GetForBrowserContext(profile)->TriggerAdd(id);
+}
+
+void VPNDelegateChromeOS::OnExtensionLoaded(
+    content::BrowserContext* browser_context,
+    const extensions::Extension* extension) {
+  if (IsVPNProvider(extension))
+    UpdateVPNProviders();
+}
+
+void VPNDelegateChromeOS::OnExtensionUnloaded(
+    content::BrowserContext* browser_context,
+    const extensions::Extension* extension,
+    extensions::UnloadedExtensionInfo::Reason reason) {
+  if (IsVPNProvider(extension))
+    UpdateVPNProviders();
+}
+
+void VPNDelegateChromeOS::OnShutdown(extensions::ExtensionRegistry* registry) {
+  DCHECK(extension_registry_);
+  extension_registry_->RemoveObserver(this);
+  extension_registry_ = nullptr;
+}
+
+void VPNDelegateChromeOS::Observe(
+    int type,
+    const content::NotificationSource& source,
+    const content::NotificationDetails& details) {
+  // A user has logged in and become the primary user. Stop watching user logins
+  // and start observing the primary user's extension registry.
+  DCHECK_EQ(chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED, type);
+  registrar_.RemoveAll();
+  AttachToPrimaryUserExtensionRegistry();
+
+}
+
+void VPNDelegateChromeOS::UpdateVPNProviders() {
+  DCHECK(extension_registry_);
+
+  vpn_providers_.clear();
+  const extensions::ExtensionSet& extensions =
+      extension_registry_->enabled_extensions();
+  for (const auto& extension : extensions) {
+    if (IsVPNProvider(extension.get())) {
+      vpn_providers_.push_back(ash::VPNProvider(extension->name(),
+                                                extension->id()));
+    }
+  }
+  // Add the built-in OpenVPN/L2TP provider. Its ID is an empty string.
+  vpn_providers_.push_back(ash::VPNProvider(
+      l10n_util::GetStringUTF8(IDS_NETWORK_VPN_BUILT_IN_PROVIDER),
+      std::string()));

[stevenjb, 2015/03/11 16:52:52]

If we are including OpenVPN/L2TP here, I think it might be better to define a
string constant for that instead of using an empty string?

Also, we maybe shouldn't do it now, but in the future we might prefer treating
OpenVPN and L2TP over IPSec separately in the UI, in which case using a string
identifier would allow us to separate those.

[bartfab (slow), 2015/03/11 17:27:04]

This is how I had implemented it at first but I ran into a problem with this:
ash needs to be able to recognize the built-in provider for UMA purposes. If I
define a constant here, I will either have to duplicate it in ash (brittle) or
share it between this code and ash (no idea how, short of wrapping it in a whole
component of its own).
We could still do it then, once we solve the caveat noted above. The ID is never
persisted anywhere, so we can always change it in the code.

+
+  NotifyObservers();
+}
+
+void VPNDelegateChromeOS::AttachToPrimaryUserExtensionRegistry() {
+  DCHECK(!extension_registry_);
+  extension_registry_ = extensions::ExtensionRegistry::Get(
+      GetProfileForPrimaryUser());
+  extension_registry_->AddObserver(this);
+
+  UpdateVPNProviders();
+}