Remove unnecessary instrumentation for several jank bugs.

net/disk_cache/blockfile/in_flight_backend_io.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 "net/disk_cache/blockfile/in_flight_backend_io.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
-#include "base/profiler/scoped_tracker.h"
 #include "base/single_thread_task_runner.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/blockfile/backend_impl.h"
 #include "net/disk_cache/blockfile/entry_impl.h"
 #include "net/disk_cache/blockfile/histogram_macros.h"
 
 // Provide a BackendImpl object to macros from histogram_macros.h.
 #define CACHE_UMA_BACKEND_IMPL_OBJ backend_
 
 namespace disk_cache {
@@ skipping 36 matching lines @@
 void BackendIO::OnDone(bool cancel) {
   if (IsEntryOperation()) {
     CACHE_UMA(TIMES, "TotalIOTime", 0, ElapsedTime());
   }
 
   if (!ReturnsEntry())
     return;
 
   if (result() == net::OK) {
     static_cast<EntryImpl*>(*entry_ptr_)->OnEntryCreated(backend_);
-    if (cancel) {
-      // TODO(vadimt): Remove ScopedTracker below once crbug.com/422516 is
-      // fixed.
-      tracked_objects::ScopedTracker tracking_profile(
-          FROM_HERE_WITH_EXPLICIT_FUNCTION("422516 BackendIO::OnDone"));
-
+    if (cancel)
       (*entry_ptr_)->Close();
-    }
   }
 }
 
 bool BackendIO::IsEntryOperation() {
   return operation_ > OP_MAX_BACKEND;
 }
 
 // Runs on the background thread.
 void BackendIO::ReferenceEntry() {
   entry_->AddRef();
@@ skipping 248 matching lines @@
     const scoped_refptr<base::SingleThreadTaskRunner>& background_thread)
     : backend_(backend),
       background_thread_(background_thread),
       ptr_factory_(this) {
 }
 
 InFlightBackendIO::~InFlightBackendIO() {
 }
 
 void InFlightBackendIO::Init(const net::CompletionCallback& callback) {
-  // TODO(vadimt): Remove wrapping the callback with
-  // ScopedTracker::TrackCallback() once crbug.com/422516 is fixed.
-  scoped_refptr<BackendIO> operation(new BackendIO(
-      this, backend_,
-      tracked_objects::ScopedTracker::TrackCallback(
-          FROM_HERE_WITH_EXPLICIT_FUNCTION("422516 InFlightBackendIO::Init"),
-          callback)));
+  scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->Init();
   PostOperation(operation.get());
 }
 
 void InFlightBackendIO::OpenEntry(const std::string& key, Entry** entry,
                                   const net::CompletionCallback& callback) {
-  scoped_refptr<BackendIO> operation(new BackendIO(
-      this, backend_, tracked_objects::ScopedTracker::TrackCallback(
-                          FROM_HERE_WITH_EXPLICIT_FUNCTION(
-                              "422516 InFlightBackendIO::OpenEntry"),
-                          callback)));
+  scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->OpenEntry(key, entry);
   PostOperation(operation.get());
 }
 
 void InFlightBackendIO::CreateEntry(const std::string& key, Entry** entry,
                                     const net::CompletionCallback& callback) {
-  scoped_refptr<BackendIO> operation(new BackendIO(
-      this, backend_, tracked_objects::ScopedTracker::TrackCallback(
-                          FROM_HERE_WITH_EXPLICIT_FUNCTION(
-                              "422516 InFlightBackendIO::CreateEntry"),
-                          callback)));
+  scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->CreateEntry(key, entry);
   PostOperation(operation.get());
 }
 
 void InFlightBackendIO::DoomEntry(const std::string& key,
                                   const net::CompletionCallback& callback) {
-  scoped_refptr<BackendIO> operation(new BackendIO(
-      this, backend_, tracked_objects::ScopedTracker::TrackCallback(
-                          FROM_HERE_WITH_EXPLICIT_FUNCTION(
-                              "422516 InFlightBackendIO::DoomEntry"),
-                          callback)));
+  scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->DoomEntry(key);
   PostOperation(operation.get());
 }
 
 void InFlightBackendIO::DoomAllEntries(
     const net::CompletionCallback& callback) {
-  scoped_refptr<BackendIO> operation(new BackendIO(
-      this, backend_, tracked_objects::ScopedTracker::TrackCallback(
-                          FROM_HERE_WITH_EXPLICIT_FUNCTION(
-                              "422516 InFlightBackendIO::DoomAllEntries"),
-                          callback)));
+  scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->DoomAllEntries();
   PostOperation(operation.get());
 }
 
 void InFlightBackendIO::DoomEntriesBetween(const base::Time initial_time,
                         const base::Time end_time,
                         const net::CompletionCallback& callback) {
-  scoped_refptr<BackendIO> operation(new BackendIO(
-      this, backend_, tracked_objects::ScopedTracker::TrackCallback(
-                          FROM_HERE_WITH_EXPLICIT_FUNCTION(
-                              "422516 InFlightBackendIO::DoomEntriesBetween"),
-                          callback)));
+  scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->DoomEntriesBetween(initial_time, end_time);
   PostOperation(operation.get());
 }
 
 void InFlightBackendIO::DoomEntriesSince(
     const base::Time initial_time, const net::CompletionCallback& callback) {
-  scoped_refptr<BackendIO> operation(new BackendIO(
-      this, backend_, tracked_objects::ScopedTracker::TrackCallback(
-                          FROM_HERE_WITH_EXPLICIT_FUNCTION(
-                              "422516 InFlightBackendIO::DoomEntriesSince"),
-                          callback)));
+  scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->DoomEntriesSince(initial_time);
   PostOperation(operation.get());
 }
 
 void InFlightBackendIO::OpenNextEntry(Rankings::Iterator* iterator,
                                       Entry** next_entry,
                                       const net::CompletionCallback& callback) {
-  scoped_refptr<BackendIO> operation(new BackendIO(
-      this, backend_, tracked_objects::ScopedTracker::TrackCallback(
-                          FROM_HERE_WITH_EXPLICIT_FUNCTION(
-                              "422516 InFlightBackendIO::OpenNextEntry"),
-                          callback)));
+  scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->OpenNextEntry(iterator, next_entry);
   PostOperation(operation.get());
 }
 
 void InFlightBackendIO::EndEnumeration(
     scoped_ptr<Rankings::Iterator> iterator) {
   scoped_refptr<BackendIO> operation(
       new BackendIO(this, backend_, net::CompletionCallback()));
   operation->EndEnumeration(iterator.Pass());
   PostOperation(operation.get());
@@ skipping 14 matching lines @@
 }
 
 void InFlightBackendIO::DoomEntryImpl(EntryImpl* entry) {
   scoped_refptr<BackendIO> operation(
       new BackendIO(this, backend_, net::CompletionCallback()));
   operation->DoomEntryImpl(entry);
   PostOperation(operation.get());
 }
 
 void InFlightBackendIO::FlushQueue(const net::CompletionCallback& callback) {
-  scoped_refptr<BackendIO> operation(new BackendIO(
-      this, backend_, tracked_objects::ScopedTracker::TrackCallback(
-                          FROM_HERE_WITH_EXPLICIT_FUNCTION(
-                              "422516 InFlightBackendIO::FlushQueue"),
-                          callback)));
+  scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->FlushQueue();
   PostOperation(operation.get());
 }
 
 void InFlightBackendIO::RunTask(
     const base::Closure& task, const net::CompletionCallback& callback) {
-  scoped_refptr<BackendIO> operation(new BackendIO(
-      this, backend_,
-      tracked_objects::ScopedTracker::TrackCallback(
-          FROM_HERE_WITH_EXPLICIT_FUNCTION("422516 InFlightBackendIO::RunTask"),
-          callback)));
+  scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->RunTask(task);
   PostOperation(operation.get());
 }
 
 void InFlightBackendIO::ReadData(EntryImpl* entry, int index, int offset,
                                  net::IOBuffer* buf, int buf_len,
                                  const net::CompletionCallback& callback) {
-  scoped_refptr<BackendIO> operation(new BackendIO(
-      this, backend_, tracked_objects::ScopedTracker::TrackCallback(
-                          FROM_HERE_WITH_EXPLICIT_FUNCTION(
-                              "422516 InFlightBackendIO::ReadData"),
-                          callback)));
+  scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->ReadData(entry, index, offset, buf, buf_len);
   PostOperation(operation.get());
 }
 
 void InFlightBackendIO::WriteData(EntryImpl* entry, int index, int offset,
                                   net::IOBuffer* buf, int buf_len,
                                   bool truncate,
                                   const net::CompletionCallback& callback) {
-  scoped_refptr<BackendIO> operation(new BackendIO(
-      this, backend_, tracked_objects::ScopedTracker::TrackCallback(
-                          FROM_HERE_WITH_EXPLICIT_FUNCTION(
-                              "422516 InFlightBackendIO::WriteData"),
-                          callback)));
+  scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->WriteData(entry, index, offset, buf, buf_len, truncate);
   PostOperation(operation.get());
 }
 
 void InFlightBackendIO::ReadSparseData(
     EntryImpl* entry, int64 offset, net::IOBuffer* buf, int buf_len,
     const net::CompletionCallback& callback) {
-  scoped_refptr<BackendIO> operation(new BackendIO(
-      this, backend_, tracked_objects::ScopedTracker::TrackCallback(
-                          FROM_HERE_WITH_EXPLICIT_FUNCTION(
-                              "422516 InFlightBackendIO::ReadSparseData"),
-                          callback)));
+  scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->ReadSparseData(entry, offset, buf, buf_len);
   PostOperation(operation.get());
 }
 
 void InFlightBackendIO::WriteSparseData(
     EntryImpl* entry, int64 offset, net::IOBuffer* buf, int buf_len,
     const net::CompletionCallback& callback) {
-  scoped_refptr<BackendIO> operation(new BackendIO(
-      this, backend_, tracked_objects::ScopedTracker::TrackCallback(
-                          FROM_HERE_WITH_EXPLICIT_FUNCTION(
-                              "422516 InFlightBackendIO::WriteSparseData"),
-                          callback)));
+  scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->WriteSparseData(entry, offset, buf, buf_len);
   PostOperation(operation.get());
 }
 
 void InFlightBackendIO::GetAvailableRange(
     EntryImpl* entry, int64 offset, int len, int64* start,
     const net::CompletionCallback& callback) {
-  scoped_refptr<BackendIO> operation(new BackendIO(
-      this, backend_, tracked_objects::ScopedTracker::TrackCallback(
-                          FROM_HERE_WITH_EXPLICIT_FUNCTION(
-                              "422516 InFlightBackendIO::GetAvailableRange"),
-                          callback)));
+  scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->GetAvailableRange(entry, offset, len, start);
   PostOperation(operation.get());
 }
 
 void InFlightBackendIO::CancelSparseIO(EntryImpl* entry) {
   scoped_refptr<BackendIO> operation(
       new BackendIO(this, backend_, net::CompletionCallback()));
   operation->CancelSparseIO(entry);
   PostOperation(operation.get());
 }
 
 void InFlightBackendIO::ReadyForSparseIO(
     EntryImpl* entry, const net::CompletionCallback& callback) {
-  scoped_refptr<BackendIO> operation(new BackendIO(
-      this, backend_, tracked_objects::ScopedTracker::TrackCallback(
-                          FROM_HERE_WITH_EXPLICIT_FUNCTION(
-                              "422516 InFlightBackendIO::CancelSparseIO"),
-                          callback)));
+  scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->ReadyForSparseIO(entry);
   PostOperation(operation.get());
 }
 
 void InFlightBackendIO::WaitForPendingIO() {
   InFlightIO::WaitForPendingIO();
 }
 
 void InFlightBackendIO::OnOperationComplete(BackgroundIO* operation,
                                             bool cancel) {
   BackendIO* op = static_cast<BackendIO*>(operation);
   op->OnDone(cancel);
 
-  if (!op->callback().is_null() && (!cancel || op->IsEntryOperation())) {
-    // TODO(vadimt): Remove ScopedTracker below once crbug.com/422516 is fixed.
-    tracked_objects::ScopedTracker tracking_profile(
-        FROM_HERE_WITH_EXPLICIT_FUNCTION(
-            "422516 InFlightBackendIO::OnOperationComplete"));
-
+  if (!op->callback().is_null() && (!cancel || op->IsEntryOperation()))
     op->callback().Run(op->result());
-  }
 }
 
 void InFlightBackendIO::PostOperation(BackendIO* operation) {
   background_thread_->PostTask(
       FROM_HERE, base::Bind(&BackendIO::ExecuteOperation, operation));
   OnOperationPosted(operation);
 }
 
 base::WeakPtr<InFlightBackendIO> InFlightBackendIO::GetWeakPtr() {
   return ptr_factory_.GetWeakPtr();
 }
 
 }  // namespace