[tracing] Replace %p with %PRIXPTR in the memory dump names

cc/tiles/gpu_image_decode_controller.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/tiles/gpu_image_decode_controller.h"
 
+#include <inttypes.h>
+
 #include "base/memory/discardable_memory_allocator.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/numerics/safe_math.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/output/context_provider.h"
 #include "cc/raster/tile_task.h"
 #include "cc/resources/resource_format_utils.h"
@@ skipping 441 matching lines @@
 bool GpuImageDecodeController::OnMemoryDump(
     const base::trace_event::MemoryDumpArgs& args,
     base::trace_event::ProcessMemoryDump* pmd) {
   for (const auto& image_pair : image_data_) {
     const ImageData* image_data = image_pair.second.get();
     const uint32_t image_id = image_pair.first;
 
     // If we have discardable decoded data, dump this here.
     if (image_data->decode.data()) {
       std::string discardable_dump_name = base::StringPrintf(
-          "cc/image_memory/controller_%p/discardable/image_%d", this, image_id);
+          "cc/image_memory/controller_0x%" PRIXPTR "/discardable/image_%d",
+          reinterpret_cast<uintptr_t>(this), image_id);
       base::trace_event::MemoryAllocatorDump* dump =
           image_data->decode.data()->CreateMemoryAllocatorDump(
               discardable_dump_name.c_str(), pmd);
 
       // If our image is locked, dump the "locked_size" as an additional column.
       // This lets us see the amount of discardable which is contributing to
       // memory pressure.
       if (image_data->decode.is_locked()) {
         dump->AddScalar("locked_size",
                         base::trace_event::MemoryAllocatorDump::kUnitsBytes,
                         image_data->size);
       }
     }
 
     // If we have an uploaded image (that is actually on the GPU, not just a CPU
     // wrapper), upload it here.
     if (image_data->upload.image() &&
         image_data->mode == DecodedDataMode::GPU) {
       std::string gpu_dump_name = base::StringPrintf(
-          "cc/image_memory/controller_%p/gpu/image_%d", this, image_id);
+          "cc/image_memory/controller_0x%" PRIXPTR "/gpu/image_%d",
+          reinterpret_cast<uintptr_t>(this), image_id);
       base::trace_event::MemoryAllocatorDump* dump =
           pmd->CreateAllocatorDump(gpu_dump_name);
       dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
                       base::trace_event::MemoryAllocatorDump::kUnitsBytes,
                       image_data->size);
 
       // Create a global shred GUID to associate this data with its GPU process
       // counterpart.
       GLuint gl_id = skia::GrBackendObjectToGrGLTextureInfo(
                          image_data->upload.image()->getTextureHandle(
@@ skipping 447 matching lines @@
 bool GpuImageDecodeController::DiscardableIsLockedForTesting(
     const DrawImage& image) {
   base::AutoLock lock(lock_);
   auto found = image_data_.Peek(image.image()->uniqueID());
   DCHECK(found != image_data_.end());
   ImageData* image_data = found->second.get();
   return image_data->decode.is_locked();
 }
 
 }  // namespace cc