Report data usage UMA for Chrome services

sync/internal_api/http_bridge.cc

 // Copyright 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 "sync/internal_api/public/http_bridge.h"
 
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 143 matching lines @@
   // init.  It would be impossible for a shutdown to have been requested at this
   // point.
   bool result = cancelation_signal_->TryRegisterHandler(this);
   DCHECK(result);
 }
 
 HttpBridgeFactory::~HttpBridgeFactory() {
   cancelation_signal_->UnregisterHandler(this);
 }
 
-void HttpBridgeFactory::Init(const std::string& user_agent) {
+void HttpBridgeFactory::Init(
+    const std::string& user_agent,
+    const BindToTrackerCallback& bind_to_tracker_callback) {
   user_agent_ = user_agent;
+  bind_to_tracker_callback_ = bind_to_tracker_callback;
 }
 
 HttpPostProviderInterface* HttpBridgeFactory::Create() {
   base::AutoLock lock(request_context_getter_lock_);
 
   // If we've been asked to shut down (something which may happen asynchronously
   // and at pretty much any time), then we won't have a request_context_getter_.
   // Some external mechanism must ensure that this function is not called after
   // we've been asked to shut down.
   CHECK(request_context_getter_.get());
 
-  scoped_refptr<HttpBridge> http = new HttpBridge(
-      user_agent_, request_context_getter_, network_time_update_callback_);
+  scoped_refptr<HttpBridge> http =
+      new HttpBridge(user_agent_, request_context_getter_,
+                     network_time_update_callback_, bind_to_tracker_callback_);
   http->AddRef();
   return http.get();
 }
 
 void HttpBridgeFactory::Destroy(HttpPostProviderInterface* http) {
   static_cast<HttpBridge*>(http)->Release();
 }
 
 void HttpBridgeFactory::OnSignalReceived() {
   base::AutoLock lock(request_context_getter_lock_);
   // Release |request_context_getter_| as soon as possible so that it
   // is destroyed in the right order on its network task runner.
   request_context_getter_ = NULL;
 }
 
 HttpBridge::URLFetchState::URLFetchState()
     : url_poster(NULL),
       aborted(false),
       request_completed(false),
       request_succeeded(false),
       http_response_code(-1),
       error_code(-1) {
 }
 HttpBridge::URLFetchState::~URLFetchState() {}
 
 HttpBridge::HttpBridge(
     const std::string& user_agent,
     const scoped_refptr<net::URLRequestContextGetter>& context_getter,
-    const NetworkTimeUpdateCallback& network_time_update_callback)
+    const NetworkTimeUpdateCallback& network_time_update_callback,
+    const BindToTrackerCallback& bind_to_tracker_callback)
     : created_on_loop_(base::MessageLoop::current()),
       user_agent_(user_agent),
       http_post_completed_(false, false),
       request_context_getter_(context_getter),
       network_task_runner_(request_context_getter_->GetNetworkTaskRunner()),
-      network_time_update_callback_(network_time_update_callback) {
-}
+      network_time_update_callback_(network_time_update_callback),
+      bind_to_tracker_callback_(bind_to_tracker_callback) {}
 
 HttpBridge::~HttpBridge() {
 }
 
 void HttpBridge::SetExtraRequestHeaders(const char * headers) {
   DCHECK(extra_headers_.empty())
       << "HttpBridge::SetExtraRequestHeaders called twice.";
   extra_headers_.assign(headers);
 }
 
@@ skipping 81 matching lines @@
   fetch_state_.http_request_timeout_timer.reset(new base::Timer(false, false));
   fetch_state_.http_request_timeout_timer->Start(
       FROM_HERE, base::TimeDelta::FromSeconds(kMaxHttpRequestTimeSeconds),
       base::Bind(&HttpBridge::OnURLFetchTimedOut, this));
 
   DCHECK(request_context_getter_.get());
   fetch_state_.start_time = base::Time::Now();
   fetch_state_.url_poster =
       net::URLFetcher::Create(url_for_request_, net::URLFetcher::POST, this)
           .release();
+  if (!bind_to_tracker_callback_.is_null())
+    bind_to_tracker_callback_.Run(fetch_state_.url_poster);
   fetch_state_.url_poster->SetRequestContext(request_context_getter_.get());
   fetch_state_.url_poster->SetExtraRequestHeaders(extra_headers_);
 
   int64 compressed_content_size = 0;
   if (IsSyncHttpContentCompressionEnabled()) {
     std::string compressed_request_content;
     GzipCompress(request_content_, &compressed_request_content);
     compressed_content_size = compressed_request_content.size();
     fetch_state_.url_poster->SetUploadData(content_type_,
                                            compressed_request_content);
@@ skipping 200 matching lines @@
   int64 sane_time_ms = 0;
   if (base::StringToInt64(sane_time_str, &sane_time_ms)) {
     network_time_update_callback_.Run(
         base::Time::FromJsTime(sane_time_ms),
         base::TimeDelta::FromMilliseconds(1),
         fetch_state_.end_time - fetch_state_.start_time);
   }
 }
 
 }  // namespace syncer