Final batch adding real histogram values for extension events.

extensions/browser/api/hid/hid_device_manager.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/hid/hid_device_manager.h"
 
 #include <limits>
 #include <vector>
 
 #include "base/lazy_instance.h"
@@ skipping 202 matching lines @@
 
   // Don't generate events during the initial enumeration.
   if (enumeration_ready_ && event_router_) {
     core_api::hid::HidDeviceInfo api_device_info;
     api_device_info.device_id = new_id;
     PopulateHidDeviceInfo(&api_device_info, device_info);
 
     if (api_device_info.collections.size() > 0) {
       scoped_ptr<base::ListValue> args(
           hid::OnDeviceAdded::Create(api_device_info));
-      DispatchEvent(hid::OnDeviceAdded::kEventName, args.Pass(), device_info);
+      DispatchEvent(events::HID_ON_DEVICE_ADDED, hid::OnDeviceAdded::kEventName,
+                    args.Pass(), device_info);
     }
   }
 }
 
 void HidDeviceManager::OnDeviceRemoved(
     scoped_refptr<HidDeviceInfo> device_info) {
   DCHECK(thread_checker_.CalledOnValidThread());
   const auto& resource_entry = resource_ids_.find(device_info->device_id());
   DCHECK(resource_entry != resource_ids_.end());
   int resource_id = resource_entry->second;
   const auto& device_entry = device_ids_.find(resource_id);
   DCHECK(device_entry != device_ids_.end());
   resource_ids_.erase(resource_entry);
   device_ids_.erase(device_entry);
 
   if (event_router_) {
     DCHECK(enumeration_ready_);
     scoped_ptr<base::ListValue> args(hid::OnDeviceRemoved::Create(resource_id));
-    DispatchEvent(hid::OnDeviceRemoved::kEventName, args.Pass(), device_info);
+    DispatchEvent(events::HID_ON_DEVICE_REMOVED,
+                  hid::OnDeviceRemoved::kEventName, args.Pass(), device_info);
   }
 }
 
 void HidDeviceManager::LazyInitialize() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (initialized_) {
     return;
   }
 
@@ skipping 55 matching lines @@
   enumeration_ready_ = true;
 
   for (const GetApiDevicesParams* params : pending_enumerations_) {
     scoped_ptr<base::ListValue> devices =
         CreateApiDeviceList(params->extension, params->filters);
     params->callback.Run(devices.Pass());
   }
   pending_enumerations_.clear();
 }
 
-void HidDeviceManager::DispatchEvent(const std::string& event_name,
+void HidDeviceManager::DispatchEvent(events::HistogramValue histogram_value,
+                                     const std::string& event_name,
                                      scoped_ptr<base::ListValue> event_args,
                                      scoped_refptr<HidDeviceInfo> device_info) {
   scoped_ptr<Event> event(
-      new Event(events::UNKNOWN, event_name, event_args.Pass()));
+      new Event(histogram_value, event_name, event_args.Pass()));
   event->will_dispatch_callback = base::Bind(
       &WillDispatchDeviceEvent, weak_factory_.GetWeakPtr(), device_info);
   event_router_->BroadcastEvent(event.Pass());
 }
 
 }  // namespace extensions