Report data usage UMA for Chrome services

sync/internal_api/http_bridge_unittest.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 "base/callback.h"
 #include "base/metrics/field_trial.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/mock_entropy_provider.h"
 #include "base/threading/thread.h"
 #include "net/http/http_response_headers.h"
 #include "net/test/spawned_test_server/spawned_test_server.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_test_util.h"
 #include "sync/internal_api/public/base/cancelation_signal.h"
 #include "sync/internal_api/public/http_bridge.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/zlib/zlib.h"
 
+namespace net {
+class URLFetcher;
+}
+
 namespace syncer {
 
 namespace {
 
 // TODO(timsteele): Should use PathService here. See Chromium Issue 3113.
 const base::FilePath::CharType kDocRoot[] =
     FILE_PATH_LITERAL("chrome/test/data");
 
 // -----------------------------------------------------------------------------
 // The rest of the code in the anon namespace is copied from
@@ skipping 106 matching lines @@
     }
     io_thread_.Stop();
   }
 
   HttpBridge* BuildBridge() {
     if (!fake_default_request_context_getter_) {
       fake_default_request_context_getter_ =
           new net::TestURLRequestContextGetter(io_thread_.task_runner());
       fake_default_request_context_getter_->AddRef();
     }
-    HttpBridge* bridge =
-        new HttpBridge(kUserAgent,
-                       fake_default_request_context_getter_,
-                       NetworkTimeUpdateCallback());
+    HttpBridge* bridge = new HttpBridge(
+        kUserAgent, fake_default_request_context_getter_,
+        NetworkTimeUpdateCallback(), base::Callback<void(net::URLFetcher*)>());
     return bridge;
   }
 
   static void Abort(HttpBridge* bridge) {
     bridge->Abort();
   }
 
   // Used by AbortAndReleaseBeforeFetchCompletes to test an interesting race
   // condition.
   void RunSyncThreadBridgeUseTest(base::WaitableEvent* signal_when_created,
@@ skipping 40 matching lines @@
 
 // An HttpBridge that doesn't actually make network requests and just calls
 // back with dummy response info.
 // TODO(tim): Instead of inheriting here we should inject a component
 // responsible for the MakeAsynchronousPost bit.
 class ShuntedHttpBridge : public HttpBridge {
  public:
   // If |never_finishes| is true, the simulated request never actually
   // returns.
   ShuntedHttpBridge(net::URLRequestContextGetter* baseline_context_getter,
-                    MAYBE_SyncHttpBridgeTest* test, bool never_finishes)
+                    MAYBE_SyncHttpBridgeTest* test,
+                    bool never_finishes)
       : HttpBridge(kUserAgent,
                    baseline_context_getter,
-                   NetworkTimeUpdateCallback()),
-        test_(test), never_finishes_(never_finishes) { }
+                   NetworkTimeUpdateCallback(),
+                   base::Callback<void(net::URLFetcher*)>()),
+        test_(test),
+        never_finishes_(never_finishes) {}
+
  protected:
   void MakeAsynchronousPost() override {
     ASSERT_TRUE(base::MessageLoop::current() == test_->GetIOThreadLoop());
     if (never_finishes_)
       return;
 
     // We don't actually want to make a request for this test, so just callback
     // as if it completed.
     test_->GetIOThreadLoop()->PostTask(FROM_HERE,
         base::Bind(&ShuntedHttpBridge::CallOnURLFetchComplete, this));
@@ skipping 347 matching lines @@
     net::URLRequestContextGetter* baseline_context_getter,
     CancelationSignal* factory_cancelation_signal,
     syncer::HttpPostProviderFactory** bridge_factory_out,
     syncer::HttpPostProviderInterface** bridge_out,
     base::WaitableEvent* signal_when_created,
     base::WaitableEvent* wait_for_shutdown) {
   scoped_ptr<syncer::HttpBridgeFactory> bridge_factory(
       new syncer::HttpBridgeFactory(baseline_context_getter,
                                     NetworkTimeUpdateCallback(),
                                     factory_cancelation_signal));
-  bridge_factory->Init("test");
+  bridge_factory->Init("test", base::Callback<void(net::URLFetcher*)>());
   *bridge_factory_out = bridge_factory.get();
 
   HttpPostProviderInterface* bridge = bridge_factory->Create();
   *bridge_out = bridge;
 
   signal_when_created->Signal();
   wait_for_shutdown->Wait();
 
   bridge_factory->Destroy(bridge);
 }
@@ skipping 73 matching lines @@
       new HttpBridgeFactory(baseline_context_getter.get(),
                             NetworkTimeUpdateCallback(),
                             &release_request_context_signal));
 
   // UI Thread: A very early shutdown request arrives and executes on the UI
   // thread before the posted sync thread task is run.
   release_request_context_signal.Signal();
 
   // Sync thread: Finally run the posted task, only to find that our
   // HttpBridgeFactory has been neutered.  Should not crash.
-  factory->Init("TestUserAgent");
+  factory->Init("TestUserAgent", base::Callback<void(net::URLFetcher*)>());
 
   // At this point, attempting to use the factory would trigger a crash.  Both
   // this test and the real world code should make sure this never happens.
 };
 
 }  // namespace syncer