Remove scoped trackers from OnAllocateLockedDiscardableSharedMemory.

content/common/host_discardable_shared_memory_manager.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 "content/common/host_discardable_shared_memory_manager.h"
 
 #include <algorithm>
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/debug/crash_logging.h"
 #include "base/lazy_instance.h"
 #include "base/memory/discardable_memory.h"
 #include "base/numerics/safe_math.h"
-#include "base/profiler/scoped_tracker.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/sys_info.h"
 #include "base/trace_event/trace_event.h"
 
 namespace content {
 namespace {
 
 class DiscardableMemoryImpl : public base::DiscardableMemory {
  public:
   DiscardableMemoryImpl(scoped_ptr<base::DiscardableSharedMemory> shared_memory,
@@ skipping 156 matching lines @@
   base::AutoLock lock(lock_);
 
   return bytes_allocated_;
 }
 
 void HostDiscardableSharedMemoryManager::AllocateLockedDiscardableSharedMemory(
     base::ProcessHandle process_handle,
     size_t size,
     DiscardableSharedMemoryId id,
     base::SharedMemoryHandle* shared_memory_handle) {
-  // TODO(erikchen): Remove ScopedTracker below once http://crbug.com/466405
-  // is fixed.
-  tracked_objects::ScopedTracker tracking_profile1(
-      FROM_HERE_WITH_EXPLICIT_FUNCTION(
-          "466405 AllocateLockedDiscardableSharedMemory::Start"));
   base::AutoLock lock(lock_);
 
   // Make sure |id| is not already in use.
   MemorySegmentMap& process_segments = processes_[process_handle];
   if (process_segments.find(id) != process_segments.end()) {
     LOG(ERROR) << "Invalid discardable shared memory ID";
     *shared_memory_handle = base::SharedMemory::NULLHandle();
     return;
   }
 
   // Memory usage must be reduced to prevent the addition of |size| from
   // taking usage above the limit. Usage should be reduced to 0 in cases
   // where |size| is greater than the limit.
   size_t limit = 0;
   // Note: the actual mapped size can be larger than requested and cause
   // |bytes_allocated_| to temporarily be larger than |memory_limit_|. The
   // error is minimized by incrementing |bytes_allocated_| with the actual
   // mapped size rather than |size| below.
   if (size < memory_limit_)
     limit = memory_limit_ - size;
 
-  // TODO(erikchen): Remove ScopedTracker below once http://crbug.com/466405
-  // is fixed.
-  tracked_objects::ScopedTracker tracking_profile2(
-      FROM_HERE_WITH_EXPLICIT_FUNCTION(
-          "466405 AllocateLockedDiscardableSharedMemory::ReduceMemoryUsage"));
   if (bytes_allocated_ > limit)
     ReduceMemoryUsageUntilWithinLimit(limit);
 
-  // TODO(erikchen): Remove ScopedTracker below once http://crbug.com/466405
-  // is fixed.
-  tracked_objects::ScopedTracker tracking_profile3(
-      FROM_HERE_WITH_EXPLICIT_FUNCTION(
-          "466405 AllocateLockedDiscardableSharedMemory::NewMemory"));
   scoped_ptr<base::DiscardableSharedMemory> memory(
       new base::DiscardableSharedMemory);
   if (!memory->CreateAndMap(size)) {
     *shared_memory_handle = base::SharedMemory::NULLHandle();
     return;
   }
 
-  // TODO(erikchen): Remove ScopedTracker below once http://crbug.com/466405
-  // is fixed.
-  tracked_objects::ScopedTracker tracking_profile4(
-      FROM_HERE_WITH_EXPLICIT_FUNCTION(
-          "466405 AllocateLockedDiscardableSharedMemory::ShareToProcess"));
   if (!memory->ShareToProcess(process_handle, shared_memory_handle)) {
     LOG(ERROR) << "Cannot share discardable memory segment";
     *shared_memory_handle = base::SharedMemory::NULLHandle();
     return;
   }
 
   base::CheckedNumeric<size_t> checked_bytes_allocated = bytes_allocated_;
   checked_bytes_allocated += memory->mapped_size();
   if (!checked_bytes_allocated.IsValid()) {
     *shared_memory_handle = base::SharedMemory::NULLHandle();
     return;
   }
 
-  // TODO(erikchen): Remove ScopedTracker below once http://crbug.com/466405
-  // is fixed.
-  tracked_objects::ScopedTracker tracking_profile5(
-      FROM_HERE_WITH_EXPLICIT_FUNCTION(
-          "466405 "
-          "AllocateLockedDiscardableSharedMemory::BytesAllocatedChanged"));
   bytes_allocated_ = checked_bytes_allocated.ValueOrDie();
   BytesAllocatedChanged(bytes_allocated_);
 
   scoped_refptr<MemorySegment> segment(new MemorySegment(memory.Pass()));
   process_segments[id] = segment.get();
   segments_.push_back(segment.get());
   std::push_heap(segments_.begin(), segments_.end(), CompareMemoryUsageTime);
 
-  // TODO(erikchen): Remove ScopedTracker below once http://crbug.com/466405
-  // is fixed.
-  tracked_objects::ScopedTracker tracking_profile6(
-      FROM_HERE_WITH_EXPLICIT_FUNCTION(
-          "466405 "
-          "AllocateLockedDiscardableSharedMemory::"
-          "ScheduleEnforceMemoryPolicy"));
   if (bytes_allocated_ > memory_limit_)
     ScheduleEnforceMemoryPolicy();
 }
 
 void HostDiscardableSharedMemoryManager::DeletedDiscardableSharedMemory(
     DiscardableSharedMemoryId id,
     base::ProcessHandle process_handle) {
   base::AutoLock lock(lock_);
 
   MemorySegmentMap& process_segments = processes_[process_handle];
@@ skipping 131 matching lines @@
 
   enforce_memory_policy_pending_ = true;
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&HostDiscardableSharedMemoryManager::EnforceMemoryPolicy,
                  weak_ptr_factory_.GetWeakPtr()),
       base::TimeDelta::FromMilliseconds(kEnforceMemoryPolicyDelayMs));
 }
 
 }  // namespace content