[draft] Patch to check potential memory leak

mojo/edk/system/channel.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 "mojo/edk/system/channel.h"
 
 #include <stddef.h>
 #include <string.h>
 
 #include <algorithm>
 #include <limits>
 #include <utility>
 
 #include "base/macros.h"
 #include "base/memory/aligned_memory.h"
 #include "base/process/process_handle.h"
 #include "mojo/edk/embedder/platform_handle.h"
 
 #if defined(OS_MACOSX) && !defined(OS_IOS)
 #include "base/mac/mach_logging.h"
 #elif defined(OS_WIN)
 #include "base/win/win_util.h"
 #endif
 
+#include "base/atomicops.h"
+
 namespace mojo {
 namespace edk {
 
 namespace {
 
 static_assert(
     IsAlignedForChannelMessage(sizeof(Channel::Message::LegacyHeader)),
     "Invalid LegacyHeader size.");
 
 static_assert(IsAlignedForChannelMessage(sizeof(Channel::Message::Header)),
@@ skipping 10 matching lines @@
               "message_type should be at the same offset in both Header "
               "structs.");
 
 }  // namespace
 
 const size_t kReadBufferSize = 4096;
 const size_t kMaxUnusedReadBufferCapacity = 4096;
 const size_t kMaxChannelMessageSize = 256 * 1024 * 1024;
 const size_t kMaxAttachedHandles = 128;
 
+static base::subtle::Atomic32 message_count_ = 0;
+
 Channel::Message::Message(size_t payload_size, size_t max_handles)
 #if defined(MOJO_EDK_LEGACY_PROTOCOL)
     : Message(payload_size, max_handles, MessageType::NORMAL_LEGACY) {

[erikchen, 2017/03/27 19:10:35]

this constructor calls another constructor, so we double count constructors :(

+  base::subtle::Barrier_AtomicIncrement(&message_count_, 1);
+  if ((message_count_ % 1024) == 0) {
+    LOG(ERROR) << "Message: " << message_count_ << " ["
+        << base::GetCurrentProcId() << "]";
+  }
 }
 #else
     : Message(payload_size, max_handles, MessageType::NORMAL) {
+  base::subtle::Barrier_AtomicIncrement(&message_count_, 1);
+  if ((message_count_ % 1024) == 0) {
+    LOG(ERROR) << "Message: " << message_count_ << " ["
+        << base::GetCurrentProcId() << "]";
+  }
 }
 #endif
 
 Channel::Message::Message(size_t payload_size,
                           size_t max_handles,
                           MessageType message_type)
     : max_handles_(max_handles) {
   DCHECK_LE(max_handles_, kMaxAttachedHandles);
+  base::subtle::Barrier_AtomicIncrement(&message_count_, 1);
+  if ((message_count_ % 1024) == 0) {
+    LOG(ERROR) << "Message: " << message_count_ << " ["
+        << base::GetCurrentProcId() << "]";
+  }
 
   const bool is_legacy_message = (message_type == MessageType::NORMAL_LEGACY);
   size_t extra_header_size = 0;
 #if defined(OS_WIN)
   // On Windows we serialize HANDLEs into the extra header space.
   extra_header_size = max_handles_ * sizeof(HandleEntry);
 #elif defined(OS_MACOSX) && !defined(OS_IOS)
   // On OSX, some of the platform handles may be mach ports, which are
   // serialised into the message buffer. Since there could be a mix of fds and
   // mach ports, we store the mach ports as an <index, port> pair (of uint32_t),
@@ skipping 50 matching lines @@
     // Initialize all handles to invalid values.
     for (size_t i = 0; i < max_handles_; ++i) {
       mach_ports_header_->entries[i] =
           {0, static_cast<uint32_t>(MACH_PORT_NULL)};
     }
 #endif
   }
 }
 
 Channel::Message::~Message() {
+  base::subtle::Barrier_AtomicIncrement(&message_count_, -1);
   base::AlignedFree(data_);
 }
 
 // static
 Channel::MessagePtr Channel::Message::Deserialize(const void* data,
                                                   size_t data_num_bytes) {
   if (data_num_bytes < sizeof(LegacyHeader))
     return nullptr;
 
   const LegacyHeader* legacy_header =
@@ skipping 525 matching lines @@
 
 bool Channel::OnControlMessage(Message::MessageType message_type,
                                const void* payload,
                                size_t payload_size,
                                ScopedPlatformHandleVectorPtr handles) {
   return false;
 }
 
 }  // namespace edk
 }  // namespace mojo