If user had consented for metrics reporting, send speech input request origin to the server.

chrome/browser/speech/speech_input_manager.cc

 // Copyright (c) 2010 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/speech/speech_input_manager.h"
 
 #include <map>
 #include <string>
 
 #include "app/l10n_util.h"
@@ skipping 19 matching lines @@
 #include "chrome/browser/browser_process.h"
 #include "chrome/installer/util/wmi.h"
 #endif
 
 namespace {
 
 // Asynchronously fetches the PC and audio hardware/driver info on windows if
 // the user has opted into UMA. This information is sent with speech input
 // requests to the server for identifying and improving quality issues with
 // specific device configurations.
-class HardwareInfo : public base::RefCountedThreadSafe<HardwareInfo> {
+class OptionalRequestInfo
+    : public base::RefCountedThreadSafe<OptionalRequestInfo> {
  public:
-  HardwareInfo() {}
+  OptionalRequestInfo() : can_report_metrics_(false) {}
 
 #if defined(OS_WIN)
   void Refresh() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
     // UMA opt-in can be checked only from the UI thread, so switch to that.
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-        NewRunnableMethod(this, &HardwareInfo::CheckUMAAndGetHardwareInfo));
+        NewRunnableMethod(this,
+                          &OptionalRequestInfo::CheckUMAAndGetHardwareInfo));
   }
 
   void CheckUMAAndGetHardwareInfo() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     if (g_browser_process->local_state()->GetBoolean(
         prefs::kMetricsReportingEnabled)) {
       // Access potentially slow OS calls from the FILE thread.
       BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
-          NewRunnableMethod(this, &HardwareInfo::GetHardwareInfo));
+          NewRunnableMethod(this, &OptionalRequestInfo::GetHardwareInfo));
     }
   }
 
   void GetHardwareInfo() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
     AutoLock lock(lock_);
+    can_report_metrics_ = true;
     value_ = UTF16ToUTF8(
         installer::WMIComputerSystem::GetModel() + L"|" +
         AudioManager::GetAudioManager()->GetAudioInputDeviceModel());
   }
 
   std::string value() {
     AutoLock lock(lock_);
     return value_;
   }
 
+  bool can_report_metrics() {
+    AutoLock lock(lock_);
+    return can_report_metrics_;
+  }
+
  private:
   Lock lock_;
   std::string value_;
+  bool can_report_metrics_;
 
 #else  // defined(OS_WIN)
   void Refresh() {}
   std::string value() { return std::string(); }
 #endif  // defined(OS_WIN)
 
-  DISALLOW_COPY_AND_ASSIGN(HardwareInfo);
+  DISALLOW_COPY_AND_ASSIGN(OptionalRequestInfo);
 };
 
 }  // namespace
 
 namespace speech_input {
 
 class SpeechInputManagerImpl : public SpeechInputManager,
                                public SpeechInputBubbleControllerDelegate,
                                public SpeechRecognizerDelegate {
  public:
   // SpeechInputManager methods.
   virtual void StartRecognition(SpeechInputManagerDelegate* delegate,
                                 int caller_id,
                                 int render_process_id,
                                 int render_view_id,
                                 const gfx::Rect& element_rect,
                                 const std::string& language,
-                                const std::string& grammar);
+                                const std::string& grammar,
+                                const std::string& origin_url);
   virtual void CancelRecognition(int caller_id);
   virtual void StopRecording(int caller_id);
 
   // SpeechRecognizer::Delegate methods.
   virtual void SetRecognitionResult(int caller_id,
                                     bool error,
                                     const SpeechInputResultArray& result);
   virtual void DidCompleteRecording(int caller_id);
   virtual void DidCompleteRecognition(int caller_id);
   virtual void OnRecognizerError(int caller_id,
@@ skipping 23 matching lines @@
 
   void CancelRecognitionAndInformDelegate(int caller_id);
 
   // Starts/restarts recognition for an existing request.
   void StartRecognitionForRequest(int caller_id);
 
   typedef std::map<int, SpeechInputRequest> SpeechRecognizerMap;
   SpeechRecognizerMap requests_;
   int recording_caller_id_;
   scoped_refptr<SpeechInputBubbleController> bubble_controller_;
-  scoped_refptr<HardwareInfo> hardware_info_;
+  scoped_refptr<OptionalRequestInfo> optional_request_info_;
 };
 
 static ::base::LazyInstance<SpeechInputManagerImpl> g_speech_input_manager_impl(
     base::LINKER_INITIALIZED);
 
 SpeechInputManager* SpeechInputManager::Get() {
   return g_speech_input_manager_impl.Pointer();
 }
 
 bool SpeechInputManager::IsFeatureEnabled() {
@@ skipping 36 matching lines @@
   return requests_.find(caller_id)->second.delegate;
 }
 
 void SpeechInputManagerImpl::StartRecognition(
     SpeechInputManagerDelegate* delegate,
     int caller_id,
     int render_process_id,
     int render_view_id,
     const gfx::Rect& element_rect,
     const std::string& language,
-    const std::string& grammar) {
+    const std::string& grammar,
+    const std::string& origin_url) {
   DCHECK(!HasPendingRequest(caller_id));
 
   bubble_controller_->CreateBubble(caller_id, render_process_id, render_view_id,
                                    element_rect);
 
-  if (!hardware_info_.get()) {
-    hardware_info_ = new HardwareInfo();
+  if (!optional_request_info_.get()) {
+    optional_request_info_ = new OptionalRequestInfo();
     // Since hardware info is optional with speech input requests, we start an
     // asynchronous fetch here and move on with recording audio. This first
     // speech input request would send an empty string for hardware info and
     // subsequent requests may have the hardware info available if the fetch
     // completed before them. This way we don't end up stalling the user with
     // a long wait and disk seeks when they click on a UI element and start
     // speaking.
-    hardware_info_->Refresh();
+    optional_request_info_->Refresh();
   }
 
   SpeechInputRequest* request = &requests_[caller_id];
   request->delegate = delegate;
-  request->recognizer = new SpeechRecognizer(this, caller_id, language,
-                                             grammar, hardware_info_->value());
+  request->recognizer = new SpeechRecognizer(
+      this, caller_id, language, grammar, optional_request_info_->value(),
+      optional_request_info_->can_report_metrics() ? origin_url : "");
   request->is_active = false;
 
   StartRecognitionForRequest(caller_id);
 }
 
 void SpeechInputManagerImpl::StartRecognitionForRequest(int caller_id) {
   DCHECK(HasPendingRequest(caller_id));
 
   // If we are currently recording audio for another caller, abort that cleanly.
   if (recording_caller_id_)
@@ skipping 119 matching lines @@
     // to the user, abort it since user has switched focus. Otherwise
     // recognition has started and keep that going so user can start speaking to
     // another element while this gets the results in parallel.
     if (recording_caller_id_ == caller_id || !requests_[caller_id].is_active) {
       CancelRecognitionAndInformDelegate(caller_id);
     }
   }
 }
 
 }  // namespace speech_input