rebased ppapi vpnProvider

extensions/browser/api/vpn_provider/vpn_service.cc

 // Copyright 2014 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 "extensions/browser/api/vpn_provider/vpn_service.h"
 
 #include <stdint.h>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/guid.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
+#include "chrome/browser/chromeos/vpn_provider/pepper_vpn_provider_service_helper.h"
 #include "chromeos/dbus/shill_third_party_vpn_driver_client.h"
 #include "chromeos/dbus/shill_third_party_vpn_observer.h"
 #include "chromeos/network/network_configuration_handler.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_type_pattern.h"
 #include "crypto/sha2.h"
 #include "extensions/browser/event_router.h"
@@ skipping 60 matching lines @@
 }
 
 VpnService::VpnConfiguration::~VpnConfiguration() {
 }
 
 void VpnService::VpnConfiguration::OnPacketReceived(
     const std::vector<char>& data) {
   if (!vpn_service_) {
     return;
   }
-  scoped_ptr<base::ListValue> event_args =
-      api_vpn::OnPacketReceived::Create(data);
-  vpn_service_->SendSignalToExtension(
-      extension_id_, extensions::events::VPN_PROVIDER_ON_PACKET_RECEIVED,
-      api_vpn::OnPacketReceived::kEventName, event_args.Pass());
+  // If the configrataion was added via de PPAPI plugin
+  if (vpn_service_->RegisteredViaPlugin(extension_id_)) {
+    vpn_provider::VpnProviderServiceHelper::GetInstance()->OnPacketReceived_UI(
+        extension_id_, data);
+  } else {
+    scoped_ptr<base::ListValue> event_args =
+        api_vpn::OnPacketReceived::Create(data);
+    vpn_service_->SendSignalToExtension(
+        extension_id_, extensions::events::VPN_PROVIDER_ON_PACKET_RECEIVED,
+        api_vpn::OnPacketReceived::kEventName, event_args.Pass());
+  }
 }
 
 void VpnService::VpnConfiguration::OnPlatformMessage(uint32_t message) {
   if (!vpn_service_) {
     return;
   }
   DCHECK_GE(api_vpn::PLATFORM_MESSAGE_LAST, message);
 
   api_vpn::PlatformMessage platform_message =
       static_cast<api_vpn::PlatformMessage>(message);
   vpn_service_->SetActiveConfiguration(
       platform_message == api_vpn::PLATFORM_MESSAGE_CONNECTED ? this : nullptr);
 
-  // TODO(kaliamoorthi): Update the lower layers to get the error message and
-  // pass in the error instead of std::string().
-  scoped_ptr<base::ListValue> event_args = api_vpn::OnPlatformMessage::Create(
-      configuration_name_, platform_message, std::string());
+  // If the configrataion was added via de PPAPI plugin
+  if (vpn_service_->RegisteredViaPlugin(extension_id_)) {
+    vpn_provider::VpnProviderServiceHelper::GetInstance()->OnPlatformMessage_UI(
+        extension_id_, configuration_name_,
+        (PP_VpnProvider_PlatformMessage)message,  // TODO: Fix mappings
+        std::string());
+  } else {
+    // TODO(kaliamoorthi): Update the lower layers to get the error message and
+    // pass in the error instead of std::string().
+    scoped_ptr<base::ListValue> event_args = api_vpn::OnPlatformMessage::Create(
+        configuration_name_, platform_message, std::string());
 
-  vpn_service_->SendSignalToExtension(
-      extension_id_, extensions::events::VPN_PROVIDER_ON_PLATFORM_MESSAGE,
-      api_vpn::OnPlatformMessage::kEventName, event_args.Pass());
+    vpn_service_->SendSignalToExtension(
+        extension_id_, extensions::events::VPN_PROVIDER_ON_PLATFORM_MESSAGE,
+        api_vpn::OnPlatformMessage::kEventName, event_args.Pass());
+  }
 }
 
 VpnService::VpnService(
     content::BrowserContext* browser_context,
     const std::string& userid_hash,
     extensions::ExtensionRegistry* extension_registry,
     extensions::EventRouter* event_router,
     ShillThirdPartyVpnDriverClient* shill_client,
     NetworkConfigurationHandler* network_configuration_handler,
     NetworkProfileHandler* network_profile_handler,
@@ skipping 18 matching lines @@
 
 VpnService::~VpnService() {
   network_configuration_handler_->RemoveObserver(this);
   network_state_handler_->RemoveObserver(this, FROM_HERE);
   extension_registry_->RemoveObserver(this);
   STLDeleteContainerPairSecondPointers(key_to_configuration_map_.begin(),
                                        key_to_configuration_map_.end());
 }
 
 void VpnService::SendShowAddDialogToExtension(const std::string& extension_id) {
-  SendSignalToExtension(extension_id,
-                        extensions::events::VPN_PROVIDER_ON_UI_EVENT,
-                        api_vpn::OnUIEvent::kEventName,
-                        api_vpn::OnUIEvent::Create(
-                            api_vpn::UI_EVENT_SHOWADDDIALOG, std::string()));
+  // If the configrataion was added via de PPAPI plugin
+  if (RegisteredViaPlugin(extension_id)) {
+    vpn_provider::VpnProviderServiceHelper::GetInstance()->OnUIEvent_UI(
+        extension_id, PP_VPN_PROVIDER_UI_EVENT_SHOWADDDIALOG, std::string());
+  } else {  // via extension
+    SendSignalToExtension(extension_id,
+                          extensions::events::VPN_PROVIDER_ON_UI_EVENT,
+                          api_vpn::OnUIEvent::kEventName,
+                          api_vpn::OnUIEvent::Create(
+                              api_vpn::UI_EVENT_SHOWADDDIALOG, std::string()));
+  }
 }
 
 void VpnService::SendShowConfigureDialogToExtension(
     const std::string& extension_id,
     const std::string& configuration_id) {
-  SendSignalToExtension(
-      extension_id, extensions::events::VPN_PROVIDER_ON_UI_EVENT,
-      api_vpn::OnUIEvent::kEventName,
-      api_vpn::OnUIEvent::Create(api_vpn::UI_EVENT_SHOWCONFIGUREDIALOG,
-                                 configuration_id));
+  // If the configrataion was added via de PPAPI plugin
+  if (RegisteredViaPlugin(extension_id)) {
+    vpn_provider::VpnProviderServiceHelper::GetInstance()->OnUIEvent_UI(
+        extension_id, PP_VPN_PROVIDER_UI_EVENT_SHOWCONFIGUREDIALOG,
+        configuration_id);
+  } else {
+    SendSignalToExtension(
+        extension_id, extensions::events::VPN_PROVIDER_ON_UI_EVENT,
+        api_vpn::OnUIEvent::kEventName,
+        api_vpn::OnUIEvent::Create(api_vpn::UI_EVENT_SHOWCONFIGUREDIALOG,
+                                   configuration_id));
+  }
 }
 
 void VpnService::SendPlatformError(const std::string& extension_id,
                                    const std::string& configuration_id,
                                    const std::string& error_message) {
-  SendSignalToExtension(
-      extension_id, extensions::events::VPN_PROVIDER_ON_PLATFORM_MESSAGE,
-      api_vpn::OnPlatformMessage::kEventName,
-      api_vpn::OnPlatformMessage::Create(
-          configuration_id, api_vpn::PLATFORM_MESSAGE_ERROR, error_message));
+  // If the configrataion was added via de PPAPI plugin
+  if (RegisteredViaPlugin(extension_id)) {
+    vpn_provider::VpnProviderServiceHelper::GetInstance()->OnPlatformMessage_UI(
+        extension_id, configuration_id, PP_VPN_PROVIDER_PLATFORM_MESSAGE_ERROR,
+        error_message);
+  } else {
+    SendSignalToExtension(
+        extension_id, extensions::events::VPN_PROVIDER_ON_PLATFORM_MESSAGE,
+        api_vpn::OnPlatformMessage::kEventName,
+        api_vpn::OnPlatformMessage::Create(
+            configuration_id, api_vpn::PLATFORM_MESSAGE_ERROR, error_message));
+  }
 }
 
 std::string VpnService::GetKey(const std::string& extension_id,
                                const std::string& name) {
   const std::string key = crypto::SHA256HashString(extension_id + name);
   return base::HexEncode(key.data(), key.size());
 }
 
 void VpnService::OnConfigurationCreated(const std::string& service_path,
                                         const std::string& profile_path,
@@ skipping 12 matching lines @@
 
   if (service_path_to_configuration_map_.find(service_path) ==
       service_path_to_configuration_map_.end()) {
     // Ignore removal of a configuration unknown to VPN service, which means the
     // configuration was created internally by the platform.
     return;
   }
 
   VpnConfiguration* configuration =
       service_path_to_configuration_map_[service_path];
-  scoped_ptr<base::ListValue> event_args =
-      api_vpn::OnConfigRemoved::Create(configuration->configuration_name());
-  SendSignalToExtension(configuration->extension_id(),
-                        extensions::events::VPN_PROVIDER_ON_CONFIG_REMOVED,
-                        api_vpn::OnConfigRemoved::kEventName,
-                        event_args.Pass());
+  // If the configrataion was added via de PPAPI plugin
+  if (RegisteredViaPlugin(configuration->extension_id())) {
+    vpn_provider::VpnProviderServiceHelper::GetInstance()
+        ->OnConfigurationRemoved_UI(configuration->extension_id(),
+                                    configuration->configuration_name());
+  } else {  // via extension
+    scoped_ptr<base::ListValue> event_args =
+        api_vpn::OnConfigRemoved::Create(configuration->configuration_name());
+    SendSignalToExtension(configuration->extension_id(),
+                          extensions::events::VPN_PROVIDER_ON_CONFIG_REMOVED,
+                          api_vpn::OnConfigRemoved::kEventName,
+                          event_args.Pass());
+  }
 
   DestroyConfigurationInternal(configuration);
 }
 
 void VpnService::OnPropertiesSet(const std::string& service_path,
                                  const std::string& guid,
                                  const base::DictionaryValue& set_properties,
                                  Source source) {
 }
 
@@ skipping 15 matching lines @@
   std::string configuration_name;
   if (!dictionary.GetString(shill::kProviderTypeProperty, &vpn_type) ||
       !dictionary.GetString(shill::kProviderHostProperty, &extension_id) ||
       !dictionary.GetString(shill::kTypeProperty, &type) ||
       !dictionary.GetString(shill::kNameProperty, &configuration_name) ||
       vpn_type != shill::kProviderThirdPartyVpn || type != shill::kTypeVPN) {
     return;
   }
 
   if (!extension_registry_->GetExtensionById(
-          extension_id, extensions::ExtensionRegistry::ENABLED)) {
+          extension_id, extensions::ExtensionRegistry::ENABLED) &&
+      !RegisteredViaPlugin(extension_id)) {
     // Does not belong to this instance of VpnService.
+    // OR to our plugin map.
     return;
   }
 
   const std::string key = GetKey(extension_id, configuration_name);
   VpnConfiguration* configuration =
       CreateConfigurationInternal(extension_id, configuration_name, key);
   configuration->set_service_path(service_path);
   service_path_to_configuration_map_[service_path] = configuration;
   shill_client_->AddShillThirdPartyVpnObserver(configuration->object_path(),
                                                configuration);
@@ skipping 286 matching lines @@
   }
   delete configuration;
 }
 
 bool VpnService::DoesActiveConfigurationExistAndIsAccessAuthorized(
     const std::string& extension_id) {
   return active_configuration_ &&
          active_configuration_->extension_id() == extension_id;
 }
 
+void VpnService::AddPlugin(const std::string& service_id) {
+  pepper_plugin_set_.insert(service_id);
+}
+
+void VpnService::RemovePlugin(const std::string& service_id) {
+  pepper_plugin_set_.erase(service_id);
+}
+
+bool VpnService::RegisteredViaPlugin(const std::string& service_id) {
+  return (pepper_plugin_set_.find(service_id) != pepper_plugin_set_.end());
+}
+
 }  // namespace chromeos