Fix the module IDs from the Mac stack sampler.

base/profiler/native_stack_sampler_mac.cc

 // Copyright 2017 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 "base/profiler/native_stack_sampler.h"
 
 #include <dlfcn.h>
 #include <libkern/OSByteOrder.h>
 #include <libunwind.h>
 #include <mach-o/swap.h>
@@ skipping 146 matching lines @@
 }
 
 const char* LibSystemKernelName() {
   static char path[PATH_MAX];
   static char* name = nullptr;
   if (name)
     return name;
 
   Dl_info info;
   dladdr(reinterpret_cast<void*>(_exit), &info);
-  strncpy(path, info.dli_fname, PATH_MAX);
+  strlcpy(path, info.dli_fname, PATH_MAX);
   name = path;
 
 #if !defined(ADDRESS_SANITIZER)
   DCHECK_EQ(std::string(name),
             std::string("/usr/lib/system/libsystem_kernel.dylib"));
 #endif
   return name;
 }
 
 // Walks the stack represented by |thread_state|, calling back to the provided
@@ skipping 37 matching lines @@
       strcmp(info.dli_fname, LibSystemKernelName()) == 0) {
       rip = *reinterpret_cast<uint64_t*>(rsp);
       rsp += 8;
       WalkStackFromContext(&unwind_context, &frame_count, callback);
     }
   }
 }
 
 // Module identifiers ---------------------------------------------------------
 
-// Returns the hex encoding of a 16-byte ID for the binary loaded at
-// |module_addr|. Returns an empty string if the UUID cannot be found at
-// |module_addr|.
+// Returns the unique build ID for a module loaded at |module_addr|. Returns the
+// empty string if the function fails to get the build ID.
+//
+// Build IDs are created by the concatenation of the module's GUID (Windows) /
+// UUID (Mac) and an "age" field that indicates how many times that GUID/UUID
+// has been reused. In Windows binaries, the "age" field is present in the
+// module header, but on the Mac, UUIDs are never reused and so the "age" value
+// appended to the UUID is always 0.
 std::string GetUniqueId(const void* module_addr) {
   const mach_header_64* mach_header =
       reinterpret_cast<const mach_header_64*>(module_addr);
   DCHECK_EQ(MH_MAGIC_64, mach_header->magic);
 
   size_t offset = sizeof(mach_header_64);
   size_t offset_limit = sizeof(mach_header_64) + mach_header->sizeofcmds;
   for (uint32_t i = 0; (i < mach_header->ncmds) &&
                        (offset + sizeof(load_command) < offset_limit);
        ++i) {
     const load_command* current_cmd = reinterpret_cast<const load_command*>(
         reinterpret_cast<const uint8_t*>(mach_header) + offset);
 
     if (offset + current_cmd->cmdsize > offset_limit) {
       // This command runs off the end of the command list. This is malformed.
       return std::string();
     }
 
     if (current_cmd->cmd == LC_UUID) {
       if (current_cmd->cmdsize < sizeof(uuid_command)) {
         // This "UUID command" is too small. This is malformed.
         return std::string();
       }
 
       const uuid_command* uuid_cmd =
           reinterpret_cast<const uuid_command*>(current_cmd);
       static_assert(sizeof(uuid_cmd->uuid) == sizeof(uuid_t),
                     "UUID field of UUID command should be 16 bytes.");
-      return HexEncode(&uuid_cmd->uuid, sizeof(uuid_cmd->uuid));
+      // The ID is comprised of the UUID concatenated with the Mac's "age" value
+      // which is always 0.
+      return HexEncode(&uuid_cmd->uuid, sizeof(uuid_cmd->uuid)) + "0";
     }
     offset += current_cmd->cmdsize;
   }
   return std::string();
 }
 
 // Gets the index for the Module containing |instruction_pointer| in
 // |modules|, adding it if it's not already present. Returns
 // StackSamplingProfiler::Frame::kUnknownModuleIndex if no Module can be
 // determined for |module|.
@@ skipping 195 matching lines @@
 
 std::unique_ptr<NativeStackSampler> NativeStackSampler::Create(
     PlatformThreadId thread_id,
     AnnotateCallback annotator,
     NativeStackSamplerTestDelegate* test_delegate) {
   return base::MakeUnique<NativeStackSamplerMac>(thread_id, annotator,
                                                  test_delegate);
 }
 
 }  // namespace base