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

chrome/common/net/url_fetcher.cc

 // Copyright (c) 2011 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/common/net/url_fetcher.h"
 
 #include <set>
 
 #include "base/compiler_specific.h"
 #include "base/lazy_instance.h"
@@ skipping 109 matching lines @@
   scoped_refptr<net::IOBuffer> buffer_;
                                      // Read buffer
   scoped_refptr<URLRequestContextGetter> request_context_getter_;
                                      // Cookie/cache info for the request
   ResponseCookies cookies_;          // Response cookies
   net::HttpRequestHeaders extra_request_headers_;
   scoped_refptr<net::HttpResponseHeaders> response_headers_;
 
   std::string upload_content_;       // HTTP POST payload
   std::string upload_content_type_;  // MIME type of POST payload
+  std::string referrer_;             // HTTP Referer header value
 
   // Used to determine how long to wait before making a request or doing a
   // retry.
   // Both of them can only be accessed on the IO thread.
   // We need not only the throttler entry for |original_URL|, but also the one
   // for |url|. For example, consider the case that URL A redirects to URL B,
   // for which the server returns a 500 response. In this case, the exponential
   // back-off release time of URL A won't increase. If we retry without
   // considering the back-off constraint of URL B, we may send out too many
   // requests for URL A in a short period of time.
@@ skipping 189 matching lines @@
   DCHECK(!request_.get());
 
   g_registry.Get().AddURLFetcherCore(this);
   request_.reset(new net::URLRequest(original_url_, this));
   int flags = request_->load_flags() | load_flags_;
   if (!g_interception_enabled) {
     flags = flags | net::LOAD_DISABLE_INTERCEPT;
   }
   request_->set_load_flags(flags);
   request_->set_context(request_context_getter_->GetURLRequestContext());
+  request_->set_referrer(referrer_);
 
   switch (request_type_) {
     case GET:
       break;
 
     case POST:
       DCHECK(!upload_content_.empty());
       DCHECK(!upload_content_type_.empty());
 
       request_->set_method("POST");
@@ skipping 125 matching lines @@
 void URLFetcher::set_upload_data(const std::string& upload_content_type,
                                  const std::string& upload_content) {
   core_->upload_content_type_ = upload_content_type;
   core_->upload_content_ = upload_content;
 }
 
 const std::string& URLFetcher::upload_data() const {
   return core_->upload_content_;
 }
 
+void URLFetcher::set_referrer(const std::string& referrer) {
+  core_->referrer_ = referrer;
+}
+
 void URLFetcher::set_load_flags(int load_flags) {
   core_->load_flags_ = load_flags;
 }
 
 int URLFetcher::load_flags() const {
   return core_->load_flags_;
 }
 
 void URLFetcher::set_extra_request_headers(
     const std::string& extra_request_headers) {
@@ skipping 27 matching lines @@
 }
 
 // static
 void URLFetcher::CancelAll() {
   Core::CancelAll();
 }
 
 URLFetcher::Delegate* URLFetcher::delegate() const {
   return core_->delegate();
 }