Final batch adding real histogram values for extension events.

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"
@@ skipping 82 matching lines @@
 }
 
 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_, api_vpn::OnPacketReceived::kEventName, event_args.Pass());
+      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());
 
   vpn_service_->SendSignalToExtension(
-      extension_id_, api_vpn::OnPlatformMessage::kEventName, event_args.Pass());
+      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, api_vpn::OnUIEvent::kEventName,
+  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, api_vpn::OnUIEvent::kEventName,
+      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, api_vpn::OnPlatformMessage::kEventName,
+      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());
 }
 
@@ skipping 17 matching lines @@
     // 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());
 
   DestroyConfigurationInternal(configuration);
 }
 
 void VpnService::OnPropertiesSet(const std::string& service_path,
                                  const std::string& guid,
                                  const base::DictionaryValue& set_properties,
                                  Source source) {
@@ skipping 279 matching lines @@
   callback.Run();
 }
 
 void VpnService::OnRemoveConfigurationFailure(
     const VpnService::FailureCallback& callback,
     const std::string& error_name,
     scoped_ptr<base::DictionaryValue> error_data) {
   callback.Run(error_name, std::string());
 }
 
-void VpnService::SendSignalToExtension(const std::string& extension_id,
-                                       const std::string& event_name,
-                                       scoped_ptr<base::ListValue> event_args) {
-  scoped_ptr<extensions::Event> event(
-      new extensions::Event(extensions::events::UNKNOWN, event_name,
-                            event_args.Pass(), browser_context_));
+void VpnService::SendSignalToExtension(
+    const std::string& extension_id,
+    extensions::events::HistogramValue histogram_value,
+    const std::string& event_name,
+    scoped_ptr<base::ListValue> event_args) {
+  scoped_ptr<extensions::Event> event(new extensions::Event(
+      histogram_value, event_name, event_args.Pass(), browser_context_));
 
   event_router_->DispatchEventToExtension(extension_id, event.Pass());
 }
 
 void VpnService::SetActiveConfiguration(
     VpnService::VpnConfiguration* configuration) {
   active_configuration_ = configuration;
 }
 
 VpnService::VpnConfiguration* VpnService::CreateConfigurationInternal(
@@ skipping 20 matching lines @@
   delete configuration;
 }
 
 bool VpnService::DoesActiveConfigurationExistAndIsAccessAuthorized(
     const std::string& extension_id) {
   return active_configuration_ &&
          active_configuration_->extension_id() == extension_id;
 }
 
 }  // namespace chromeos