Mojo: Add leak detection to mojo::embedder::test::Shutdown().

mojo/system/core_impl.h

 // Copyright 2013 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.
 
 #ifndef MOJO_SYSTEM_CORE_IMPL_H_
 #define MOJO_SYSTEM_CORE_IMPL_H_
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/containers/hash_tables.h"
 #include "base/memory/ref_counted.h"
 #include "base/synchronization/lock.h"
 #include "mojo/public/system/core_private.h"
 #include "mojo/system/system_impl_export.h"
 
 namespace mojo {
-
 namespace system {
 
 class CoreImpl;
 class Dispatcher;
 
+// Test-only function (defined/used in embedder/test_embedder.cc). Declared here
+// so it can be friended.
+namespace internal {
+bool ShutdownCheckNoLeaks(CoreImpl*);

[sky, 2014/01/17 20:29:01]

I believe the style guide says you should name the parameters here too. But I
could be wrong.

+}
+
 // |CoreImpl| is a singleton object that implements the Mojo system calls. All
 // public methods are thread-safe.
 class MOJO_SYSTEM_IMPL_EXPORT CoreImpl : public Core {
  public:
   // These methods are only to be used by via the embedder API.
   CoreImpl();
   virtual ~CoreImpl();
   MojoHandle AddDispatcher(const scoped_refptr<Dispatcher>& dispatcher);
 
   // |CorePrivate| implementation:
@@ skipping 40 matching lines @@
                               uint32_t* num_bytes,
                               MojoReadDataFlags flags) OVERRIDE;
   virtual MojoResult BeginReadData(MojoHandle data_pipe_consumer_handle,
                                    const void** buffer,
                                    uint32_t* buffer_num_bytes,
                                    MojoReadDataFlags flags) OVERRIDE;
   virtual MojoResult EndReadData(MojoHandle data_pipe_consumer_handle,
                                  uint32_t num_bytes_read) OVERRIDE;
 
  private:
+  friend bool internal::ShutdownCheckNoLeaks(CoreImpl*);
+
   // The |busy| member is used only to deal with functions (in particular
   // |WriteMessage()|) that want to hold on to a dispatcher and later remove it
   // from the handle table, without holding on to the handle table lock.
   //
   // For example, if |WriteMessage()| is called with a handle to be sent, (under
   // the handle table lock) it must first check that that handle is not busy (if
   // it is busy, then it fails with |MOJO_RESULT_BUSY|) and then marks it as
   // busy. To avoid deadlock, it should also try to acquire the locks for all
   // the dispatchers for the handles that it is sending (and fail with
   // |MOJO_RESULT_BUSY| if the attempt fails). At this point, it can release the
@@ skipping 45 matching lines @@
   base::Lock handle_table_lock_;  // Protects the immediately-following members.
   HandleTableMap handle_table_;
   MojoHandle next_handle_;  // Invariant: never |MOJO_HANDLE_INVALID|.
 
   // ---------------------------------------------------------------------------
 
   DISALLOW_COPY_AND_ASSIGN(CoreImpl);
 };
 
 }  // namespace system
-
 }  // namespace mojo
 
 #endif  // MOJO_SYSTEM_CORE_IMPL_H_