Refactoring: Move some classes from content/child to platform

third_party/WebKit/Source/platform/WebProcessMemoryDumpImpl.cpp

 // Copyright 2015 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/child/web_process_memory_dump_impl.h"
+#include "platform/WebProcessMemoryDumpImpl.h"
 
 #include <stddef.h>
 
 #include "base/memory/discardable_memory.h"
 #include "base/trace_event/heap_profiler_heap_dump_writer.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "base/trace_event/trace_event_memory_overhead.h"
-#include "content/child/web_memory_allocator_dump_impl.h"
+#include "platform/WebMemoryAllocatorDumpImpl.h"
 #include "skia/ext/skia_trace_memory_dump_impl.h"
 
-namespace content {
+namespace blink {
 
 WebProcessMemoryDumpImpl::WebProcessMemoryDumpImpl()
     : owned_process_memory_dump_(
-          new base::trace_event::ProcessMemoryDump(nullptr)),
+          adoptPtr(new base::trace_event::ProcessMemoryDump(nullptr))),
       process_memory_dump_(owned_process_memory_dump_.get()),
       level_of_detail_(base::trace_event::MemoryDumpLevelOfDetail::DETAILED) {}
 
 WebProcessMemoryDumpImpl::WebProcessMemoryDumpImpl(
     base::trace_event::MemoryDumpLevelOfDetail level_of_detail,
     base::trace_event::ProcessMemoryDump* process_memory_dump)
     : process_memory_dump_(process_memory_dump),
       level_of_detail_(level_of_detail) {}
 
 WebProcessMemoryDumpImpl::~WebProcessMemoryDumpImpl() {
@@ skipping 27 matching lines @@
   if (!memory_allocator_dump)
     return nullptr;
 
   // Wrap it and return to blink.
   WebMemoryAllocatorDumpImpl* web_memory_allocator_dump_impl =
       new WebMemoryAllocatorDumpImpl(memory_allocator_dump);
 
   // memory_allocator_dumps_ will take ownership of
   // |web_memory_allocator_dumpd_impl|.
   memory_allocator_dumps_.set(memory_allocator_dump,
-                              make_scoped_ptr(web_memory_allocator_dump_impl));
+                              adoptPtr(web_memory_allocator_dump_impl));
   return web_memory_allocator_dump_impl;
 }
 
 blink::WebMemoryAllocatorDump* WebProcessMemoryDumpImpl::getMemoryAllocatorDump(
     const blink::WebString& absolute_name) const {
   // Retrieve the base MemoryAllocatorDump object and then reverse lookup
   // its wrapper.
   base::trace_event::MemoryAllocatorDump* memory_allocator_dump =
       process_memory_dump_->GetAllocatorDump(absolute_name.utf8());
   if (!memory_allocator_dump)
@@ skipping 24 matching lines @@
   // In order to expose the move and ownership transfer semantics of the
   // underlying ProcessMemoryDump, we need to:
 
   // 1) Move and transfer the ownership of the wrapped
   // base::trace_event::MemoryAllocatorDump(s) instances.
   process_memory_dump_->TakeAllDumpsFrom(other_impl->process_memory_dump_);
 
   // 2) Move and transfer the ownership of the WebMemoryAllocatorDump wrappers.
   const size_t expected_final_size = memory_allocator_dumps_.size() +
                                      other_impl->memory_allocator_dumps_.size();
-  while (!other_impl->memory_allocator_dumps_.empty()) {
+  while (!other_impl->memory_allocator_dumps_.isEmpty()) {
     auto first_entry = other_impl->memory_allocator_dumps_.begin();
     base::trace_event::MemoryAllocatorDump* memory_allocator_dump =
-        first_entry->first;
+        first_entry->key;
     memory_allocator_dumps_.set(
         memory_allocator_dump,
-        other_impl->memory_allocator_dumps_.take_and_erase(first_entry));
+        other_impl->memory_allocator_dumps_.take(first_entry->key));
   }
   DCHECK_EQ(expected_final_size, memory_allocator_dumps_.size());
-  DCHECK(other_impl->memory_allocator_dumps_.empty());
+  DCHECK(other_impl->memory_allocator_dumps_.isEmpty());
 }
 
 void WebProcessMemoryDumpImpl::addOwnershipEdge(
     blink::WebMemoryAllocatorDumpGuid source,
     blink::WebMemoryAllocatorDumpGuid target,
     int importance) {
   process_memory_dump_->AddOwnershipEdge(
       base::trace_event::MemoryAllocatorDumpGuid(source),
       base::trace_event::MemoryAllocatorDumpGuid(target), importance);
 }
 
 void WebProcessMemoryDumpImpl::addOwnershipEdge(
     blink::WebMemoryAllocatorDumpGuid source,
     blink::WebMemoryAllocatorDumpGuid target) {
   process_memory_dump_->AddOwnershipEdge(
       base::trace_event::MemoryAllocatorDumpGuid(source),
       base::trace_event::MemoryAllocatorDumpGuid(target));
 }
 
 void WebProcessMemoryDumpImpl::addSuballocation(
     blink::WebMemoryAllocatorDumpGuid source,
     const blink::WebString& target_node_name) {
   process_memory_dump_->AddSuballocation(
       base::trace_event::MemoryAllocatorDumpGuid(source),
       target_node_name.utf8());
 }
 
 SkTraceMemoryDump* WebProcessMemoryDumpImpl::createDumpAdapterForSkia(
     const blink::WebString& dump_name_prefix) {
-  sk_trace_dump_list_.push_back(new skia::SkiaTraceMemoryDumpImpl(
-      dump_name_prefix.utf8(), level_of_detail_, process_memory_dump_));
-  return sk_trace_dump_list_.back();
+  sk_trace_dump_list_.append(adoptPtr(new skia::SkiaTraceMemoryDumpImpl(
+      dump_name_prefix.utf8(), level_of_detail_, process_memory_dump_)));
+  return sk_trace_dump_list_.last().get();
 }
 
 blink::WebMemoryAllocatorDump*
 WebProcessMemoryDumpImpl::CreateDiscardableMemoryAllocatorDump(
     const std::string& name,
     base::DiscardableMemory* discardable) {
   base::trace_event::MemoryAllocatorDump* dump =
       discardable->CreateMemoryAllocatorDump(name.c_str(),
                                              process_memory_dump_);
   return createWebMemoryAllocatorDump(dump);
 }
 
 void WebProcessMemoryDumpImpl::dumpHeapUsage(
     const base::hash_map<base::trace_event::AllocationContext, size_t>&
         bytes_by_context,
     base::trace_event::TraceEventMemoryOverhead& overhead,
     const char* allocator_name) {
   scoped_refptr<base::trace_event::MemoryDumpSessionState> session_state =
       process_memory_dump_->session_state();
   scoped_refptr<base::trace_event::TracedValue> heap_dump = ExportHeapDump(
       bytes_by_context,
       session_state->stack_frame_deduplicator(),
       session_state->type_name_deduplicator());
   process_memory_dump_->AddHeapDump(allocator_name, heap_dump);
   overhead.DumpInto("tracing/heap_profiler", process_memory_dump_);
 }
 
 }  // namespace content