Add tracing to all url requests.

mojo/services/network/url_loader_impl.cc

 // Copyright 2014 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 "mojo/services/network/url_loader_impl.h"
 
 #include <memory>
 
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
+#include "base/trace_event/trace_event.h"
 #include "mojo/common/common_type_converters.h"
 #include "mojo/common/url_type_converters.h"
 #include "mojo/services/network/net_adapters.h"
 #include "mojo/services/network/network_context.h"
 #include "net/base/elements_upload_data_stream.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/upload_bytes_element_reader.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/redirect_info.h"
@@ skipping 28 matching lines @@
   url_request->GetMimeType(&mime_type);
   response->mime_type = mime_type;
 
   std::string charset;
   url_request->GetCharset(&charset);
   response->charset = charset;
 
   return response.Pass();
 }
 
+void RunCallbackAndTrace(const char* event_name,
+                         void* id,
+                         const Callback<void(URLResponsePtr)>& callback,
+                         URLResponsePtr response) {
+  callback.Run(response.Pass());
+  TRACE_EVENT_ASYNC_END0("net", event_name, id);
+}
+
 // Reads the request body upload data from a DataPipe.
 class UploadDataPipeElementReader : public net::UploadElementReader {
  public:
   UploadDataPipeElementReader(ScopedDataPipeConsumerHandle pipe)
       : pipe_(pipe.Pass()), num_bytes_(0) {}
   ~UploadDataPipeElementReader() override {}
 
   // UploadElementReader overrides:
   int Init(const net::CompletionCallback& callback) override {
     offset_ = 0;
@@ skipping 221 matching lines @@
 }
 
 void URLLoaderImpl::Cleanup() {
   // The associated network context is going away and we have to destroy
   // net::URLRequest hold by this loader.
   delete this;
 }
 
 void URLLoaderImpl::Start(URLRequestPtr request,
                           const Callback<void(URLResponsePtr)>& callback) {
+  TRACE_EVENT_ASYNC_BEGIN1("net", "URLLoaderImpl::Start", this, "url",
+                           request->url.get());
+  Callback<void(URLResponsePtr)> traced_callback =
+      base::Bind(&RunCallbackAndTrace, "URLLoaderImpl::Start", this, callback);
+
   if (url_request_) {
-    SendError(net::ERR_UNEXPECTED, callback);
+    SendError(net::ERR_UNEXPECTED, traced_callback);
     return;
   }
 
-  callback_ = callback;
+  callback_ = traced_callback;
   StartInternal(request.Pass());
 }
 
 void URLLoaderImpl::FollowRedirect(
     const Callback<void(URLResponsePtr)>& callback) {
+  TRACE_EVENT_ASYNC_BEGIN0("net", "URLLoaderImpl::FollowRedirect", this);
+  Callback<void(URLResponsePtr)> traced_callback = base::Bind(
+      &RunCallbackAndTrace, "URLLoaderImpl::FollowRedirect", this, callback);

[ppi, 2015/08/03 14:50:22]

Can the id (here being the value of |this|) be the same for 2+ async trace
events?

+
   if (!redirect_info_) {
     DLOG(ERROR) << "Spurious call to FollowRedirect";
-    SendError(net::ERR_UNEXPECTED, callback);
+    SendError(net::ERR_UNEXPECTED, traced_callback);
     return;
   }
   DCHECK(url_request_);
   DCHECK(url_request_->is_redirecting());
   DCHECK(!auto_follow_redirects_);
 
-  callback_ = callback;
+  callback_ = traced_callback;
   FollowRedirectInternal();
 }
 
 void URLLoaderImpl::QueryStatus(
     const Callback<void(URLLoaderStatusPtr)>& callback) {
   URLLoaderStatusPtr status(URLLoaderStatus::New());
   if (url_request_) {
     // A url request is owned by this class, the status is deduced from it.
     status->is_loading = url_request_->is_pending();
     if (!url_request_->status().is_success())
@@ skipping 266 matching lines @@
   if ((*it)->id() == current_fetcher_id_) {
     last_status_ = fetcher->QueryStatus();
     last_status_->is_loading = false;
   }
   body_fetchers_.erase(it);
   if (body_fetchers_.empty() and !binding_.is_bound())
     delete this;
 }
 
 }  // namespace mojo