Revert of Add BACKGROUND dump mode to various GPU/CC MemoryDumpProviders

cc/raster/staging_buffer_pool.cc

 // Copyright 2016 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 "cc/raster/staging_buffer_pool.h"
 
 #include <memory>
 
 #include "base/memory/memory_coordinator_client_registry.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "cc/base/container_util.h"
 #include "cc/debug/traced_value.h"
 #include "cc/resources/scoped_resource.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "ui/gfx/gpu_memory_buffer_tracing.h"
 
-using base::trace_event::MemoryAllocatorDump;
-using base::trace_event::MemoryAllocatorDumpGuid;
-using base::trace_event::MemoryDumpLevelOfDetail;
-
 namespace cc {
 namespace {
 
 // Delay between checking for query result to be available.
 const int kCheckForQueryResultAvailableTickRateMs = 1;
 
 // Number of attempts to allow before we perform a check that will wait for
 // query to complete.
 const int kMaxCheckForQueryResultAvailableAttempts = 256;
 
@@ skipping 59 matching lines @@
 
 void StagingBuffer::OnMemoryDump(base::trace_event::ProcessMemoryDump* pmd,
                                  ResourceFormat format,
                                  bool in_free_list) const {
   if (!gpu_memory_buffer)
     return;
 
   gfx::GpuMemoryBufferId buffer_id = gpu_memory_buffer->GetId();
   std::string buffer_dump_name =
       base::StringPrintf("cc/one_copy/staging_memory/buffer_%d", buffer_id.id);
-  MemoryAllocatorDump* buffer_dump = pmd->CreateAllocatorDump(buffer_dump_name);
+  base::trace_event::MemoryAllocatorDump* buffer_dump =
+      pmd->CreateAllocatorDump(buffer_dump_name);
 
   uint64_t buffer_size_in_bytes =
       ResourceUtil::UncheckedSizeInBytes<uint64_t>(size, format);
-  buffer_dump->AddScalar(MemoryAllocatorDump::kNameSize,
-                         MemoryAllocatorDump::kUnitsBytes,
+  buffer_dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
+                         base::trace_event::MemoryAllocatorDump::kUnitsBytes,
                          buffer_size_in_bytes);
-  buffer_dump->AddScalar("free_size", MemoryAllocatorDump::kUnitsBytes,
+  buffer_dump->AddScalar("free_size",
+                         base::trace_event::MemoryAllocatorDump::kUnitsBytes,
                          in_free_list ? buffer_size_in_bytes : 0);
 
   // Emit an ownership edge towards a global allocator dump node.
   const uint64_t tracing_process_id =
       base::trace_event::MemoryDumpManager::GetInstance()
           ->GetTracingProcessId();
-  MemoryAllocatorDumpGuid shared_buffer_guid =
+  base::trace_event::MemoryAllocatorDumpGuid shared_buffer_guid =
       gfx::GetGpuMemoryBufferGUIDForTracing(tracing_process_id, buffer_id);
   pmd->CreateSharedGlobalAllocatorDump(shared_buffer_guid);
 
   // By creating an edge with a higher |importance| (w.r.t. browser-side dumps)
   // the tracing UI will account the effective size of the buffer to the child.
   const int kImportance = 2;
   pmd->AddOwnershipEdge(buffer_dump->guid(), shared_buffer_guid, kImportance);
 }
 
 StagingBufferPool::StagingBufferPool(base::SequencedTaskRunner* task_runner,
@@ skipping 54 matching lines @@
   busy_buffers_.push_back(std::move(staging_buffer));
 
   ScheduleReduceMemoryUsage();
 }
 
 bool StagingBufferPool::OnMemoryDump(
     const base::trace_event::MemoryDumpArgs& args,
     base::trace_event::ProcessMemoryDump* pmd) {
   base::AutoLock lock(lock_);
 
-  if (args.level_of_detail == MemoryDumpLevelOfDetail::BACKGROUND) {
-    std::string dump_name("cc/one_copy/staging_memory");
-    MemoryAllocatorDump* dump = pmd->CreateAllocatorDump(dump_name);
-    dump->AddScalar(MemoryAllocatorDump::kNameSize,
-                    MemoryAllocatorDump::kUnitsBytes,
-                    staging_buffer_usage_in_bytes_);
-  } else {
-    for (const auto* buffer : buffers_) {
-      auto in_free_buffers =
-          std::find_if(free_buffers_.begin(), free_buffers_.end(),
-                       [buffer](const std::unique_ptr<StagingBuffer>& b) {
-                         return b.get() == buffer;
-                       });
-      buffer->OnMemoryDump(pmd, buffer->format,
-                           in_free_buffers != free_buffers_.end());
-    }
+  for (const auto* buffer : buffers_) {
+    auto in_free_buffers =
+        std::find_if(free_buffers_.begin(), free_buffers_.end(),
+                     [buffer](const std::unique_ptr<StagingBuffer>& b) {
+                       return b.get() == buffer;
+                     });
+    buffer->OnMemoryDump(pmd, buffer->format,
+                         in_free_buffers != free_buffers_.end());
   }
+
   return true;
 }
 
 void StagingBufferPool::AddStagingBuffer(const StagingBuffer* staging_buffer,
                                          ResourceFormat format) {
   lock_.AssertAcquired();
 
   DCHECK(buffers_.find(staging_buffer) == buffers_.end());
   buffers_.insert(staging_buffer);
   int buffer_usage_in_bytes =
@@ skipping 227 matching lines @@
       // Release all buffers, regardless of how recently they were used.
       ReleaseBuffersNotUsedSince(base::TimeTicks() + base::TimeDelta::Max());
     } break;
     case base::MemoryState::UNKNOWN:
       // NOT_REACHED.
       break;
   }
 }
 
 }  // namespace cc