Set up the infrastructure for Extension event metrics.

chrome/browser/copresence/chrome_whispernet_client.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 "chrome/browser/copresence/chrome_whispernet_client.h"
 
 #include "base/stl_util.h"
 #include "chrome/browser/copresence/chrome_whispernet_config.h"
 #include "chrome/browser/extensions/api/copresence_private/copresence_private_api.h"
 #include "chrome/browser/extensions/component_loader.h"
@@ skipping 115 matching lines @@
     AudioType type,
     const TokenParameters token_params[2]) {
   DCHECK(type == AUDIBLE || type == INAUDIBLE);
 
   EncodeTokenParameters params;
   params.token.token = token_str;
   params.token.audible = (type == AUDIBLE);
   ConvertTokenParams(token_params[type], &params.token_params);
 
   SendEventIfLoaded(make_scoped_ptr(new Event(
-      OnEncodeTokenRequest::kEventName,
-      OnEncodeTokenRequest::Create(client_id_, params),
-      browser_context_)));
+      extensions::events::UNKNOWN, OnEncodeTokenRequest::kEventName,
+      OnEncodeTokenRequest::Create(client_id_, params), browser_context_)));
 }
 
 void ChromeWhispernetClient::DecodeSamples(
     AudioType type,
     const std::string& samples,
     const TokenParameters token_params[2]) {
   DecodeSamplesParameters params;
   params.samples.assign(samples.begin(), samples.end());
   params.decode_audible = (type == AUDIBLE || type == BOTH);
   params.decode_inaudible = (type == INAUDIBLE || type == BOTH);
   ConvertTokenParams(token_params[AUDIBLE], &params.audible_token_params);
   ConvertTokenParams(token_params[INAUDIBLE], &params.inaudible_token_params);
 
   SendEventIfLoaded(make_scoped_ptr(new Event(
-      OnDecodeSamplesRequest::kEventName,
-      OnDecodeSamplesRequest::Create(client_id_, params),
-      browser_context_)));
+      extensions::events::UNKNOWN, OnDecodeSamplesRequest::kEventName,
+      OnDecodeSamplesRequest::Create(client_id_, params), browser_context_)));
 }
 
 void ChromeWhispernetClient::RegisterTokensCallback(
     const TokensCallback& tokens_callback) {
   tokens_callback_ = tokens_callback;
 }
 
 void ChromeWhispernetClient::RegisterSamplesCallback(
     const SamplesCallback& samples_callback) {
   samples_callback_ = samples_callback;
@@ skipping 19 matching lines @@
   AudioParameters audio_params;
 
   // We serialize AudioConfigData to a string and send it to the whispernet
   // nacl wrapper.
   const size_t params_size = sizeof(params);
   audio_params.param_data.resize(params_size);
   memcpy(vector_as_array(&audio_params.param_data), &params, params_size);
 
   DVLOG(3) << "Configuring audio for client " << client_id_;
   SendEventIfLoaded(make_scoped_ptr(new Event(
-      OnConfigAudio::kEventName,
-      OnConfigAudio::Create(client_id_, audio_params),
-      browser_context_)));
+      extensions::events::UNKNOWN, OnConfigAudio::kEventName,
+      OnConfigAudio::Create(client_id_, audio_params), browser_context_)));
 }
 
 void ChromeWhispernetClient::SendEventIfLoaded(
     scoped_ptr<extensions::Event> event) {
   DCHECK(event_router_);
 
   if (extension_loaded_) {
     event_router_->DispatchEventToExtension(kWhispernetProxyExtensionId,
                                             event.Pass());
   } else {
@@ skipping 15 matching lines @@
   // Thus we can just discard the pointers at the end.
   DCHECK(event_router_);
   for (Event* event : queued_events_) {
     event_router_->DispatchEventToExtension(kWhispernetProxyExtensionId,
                                             make_scoped_ptr(event));
   }
   queued_events_.weak_clear();
 
   extension_loaded_ = true;
 }