Drop support for uploading hardware info with speech recognition requests

chrome/browser/speech/chrome_speech_recognition_manager_delegate.cc

 // Copyright (c) 2012 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/chrome_speech_recognition_manager_delegate.h"
 
 #include <set>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 46 matching lines @@
   // this task (from the UI thread) and this call (on the IO thread). In this
   // case we just return.
   if (!manager)
     return;
 
   manager->AbortAllSessionsForRenderView(render_process_id, render_view_id);
 }
 
 }  // namespace
 
-
-// Asynchronously fetches the PC and audio hardware/driver info 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 ChromeSpeechRecognitionManagerDelegate::OptionalRequestInfo
-    : public base::RefCountedThreadSafe<OptionalRequestInfo> {
- public:
-  OptionalRequestInfo() : can_report_metrics_(false) {
-  }
-
-  void Refresh() {
-    DCHECK_CURRENTLY_ON(BrowserThread::IO);
-    // UMA opt-in can be checked only from the UI thread, so switch to that.
-    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-        base::Bind(&OptionalRequestInfo::CheckUMAAndGetHardwareInfo, this));
-  }
-
-  void CheckUMAAndGetHardwareInfo() {
-    DCHECK_CURRENTLY_ON(BrowserThread::UI);
-    // TODO(hans): Move this check to where hardware info gets sent
-    // crbug.com/533496
-    if (ChromeMetricsServiceAccessor::IsMetricsAndCrashReportingEnabled()) {
-      // Access potentially slow OS calls from the FILE thread.
-      BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
-          base::Bind(&OptionalRequestInfo::GetHardwareInfo, this));
-    }
-  }
-
-  void GetHardwareInfo() {
-    DCHECK_CURRENTLY_ON(BrowserThread::FILE);
-    base::AutoLock lock(lock_);
-    can_report_metrics_ = true;
-    base::string16 device_model =
-        SpeechRecognitionManager::GetInstance()->GetAudioInputDeviceModel();
-#if defined(OS_WIN)
-    value_ = base::UTF16ToUTF8(
-        installer::WMIComputerSystem::GetModel() + L"|" + device_model);
-#else  // defined(OS_WIN)
-    value_ = base::UTF16ToUTF8(device_model);
-#endif  // defined(OS_WIN)
-  }
-
-  std::string value() {
-    base::AutoLock lock(lock_);
-    return value_;
-  }
-
-  bool can_report_metrics() {
-    base::AutoLock lock(lock_);
-    return can_report_metrics_;
-  }
-
- private:
-  friend class base::RefCountedThreadSafe<OptionalRequestInfo>;
-
-  ~OptionalRequestInfo() {}
-
-  base::Lock lock_;
-  std::string value_;
-  bool can_report_metrics_;
-
-  DISALLOW_COPY_AND_ASSIGN(OptionalRequestInfo);
-};
-
 // Simple utility to get notified when a WebContent (a tab or an extension's
 // background page) is closed or crashes. The callback will always be called on
 // the UI thread.
 // There is no restriction on the constructor, however this class must be
 // destroyed on the UI thread, due to the NotificationRegistrar dependency.
 class ChromeSpeechRecognitionManagerDelegate::TabWatcher
     : public base::RefCountedThreadSafe<TabWatcher> {
  public:
   typedef base::Callback<void(int render_process_id, int render_view_id)>
       TabClosedCallback;
@@ skipping 182 matching lines @@
     int session_id, const content::SpeechRecognitionError& error) {
 }
 
 void ChromeSpeechRecognitionManagerDelegate::OnAudioLevelsChange(
     int session_id, float volume, float noise_volume) {
 }
 
 void ChromeSpeechRecognitionManagerDelegate::OnRecognitionEnd(int session_id) {
 }
 
-void ChromeSpeechRecognitionManagerDelegate::GetDiagnosticInformation(
-    bool* can_report_metrics,
-    std::string* hardware_info) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  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.
-    optional_request_info_->Refresh();
-  }
-  *can_report_metrics = optional_request_info_->can_report_metrics();
-  *hardware_info = optional_request_info_->value();
-}
-
 void ChromeSpeechRecognitionManagerDelegate::CheckRecognitionIsAllowed(
     int session_id,
     base::Callback<void(bool ask_user, bool is_allowed)> callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   const content::SpeechRecognitionSessionContext& context =
       SpeechRecognitionManager::GetInstance()->GetSessionContext(session_id);
 
   // Make sure that initiators (extensions/web pages) properly set the
   // |render_process_id| field, which is needed later to retrieve the profile.
@@ skipping 73 matching lines @@
   // Otherwise this should be a regular tab contents.
   allowed = true;
   check_permission = true;
 #endif
 
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                           base::Bind(callback, check_permission, allowed));
 }
 
 }  // namespace speech