[tracing] Send unique tracing process id for cross-process memory dumps identification.

base/trace_event/memory_dump_manager.h

 // 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.
 
 #ifndef BASE_TRACE_EVENT_MEMORY_DUMP_MANAGER_H_
 #define BASE_TRACE_EVENT_MEMORY_DUMP_MANAGER_H_
 
 #include <vector>
 
 #include "base/atomicops.h"
@@ skipping 18 matching lines @@
 class MemoryDumpManagerDelegate;
 class MemoryDumpProvider;
 class ProcessMemoryDump;
 class MemoryDumpSessionState;
 
 // This is the interface exposed to the rest of the codebase to deal with
 // memory tracing. The main entry point for clients is represented by
 // RequestDumpPoint(). The extension by Un(RegisterDumpProvider).
 class BASE_EXPORT MemoryDumpManager : public TraceLog::EnabledStateObserver {
  public:
+  static const int kInvalidTracingProcessId = -1;
   static const char* const kTraceCategoryForTesting;
 
   static MemoryDumpManager* GetInstance();
 
   // Invoked once per process to register the TraceLog observer.
   void Initialize();
 
   // See the lifetime and thread-safety requirements on the delegate below in
   // the |MemoryDumpManagerDelegate| docstring.
   void SetDelegate(MemoryDumpManagerDelegate* delegate);
@@ skipping 25 matching lines @@
   void OnTraceLogEnabled() override;
   void OnTraceLogDisabled() override;
 
   // Returns the MemoryDumpSessionState object, which is shared by all the
   // ProcessMemoryDump and MemoryAllocatorDump instances through all the tracing
   // session lifetime.
   const scoped_refptr<MemoryDumpSessionState>& session_state() const {
     return session_state_;
   }
 
+  // This is used by browser to hash child id to get the tracing_process_id

[Primiano Tucci (use gerrit), 2015/06/24 09:31:00]

Add the following comment here

// Derives a tracing process id from a child process id. Child process ids
// cannot be used directly in tracing for security reasons (see: discussion in
// crrev.com/xxxxxx). This method is meant to be used when dumping cross-process
// shared memory from a process which knows the child process id of its
// endpoints. The value returned by this method is guaranteed to be equal to
// the value returned by tracing_process_id() in the corresponding child
process.

+  // for child.
+  static int ChildProcessIdToTracingProcessId(int child_id);
+
+  int tracing_process_id() const {

[Primiano Tucci (use gerrit), 2015/06/24 09:31:00]

Add a comment saying:

// Returns a unique id for the current process. The id can be retrieved only
// by child processes and only when tracing is enabled. This is intended to 
// express cross-process sharing of memory dumps on the child-process side,
// without having to know the self child process id.

+    // This cannot be requested out of scope of a trace.
+    DCHECK_NE(tracing_process_id_, kInvalidTracingProcessId);
+    return tracing_process_id_;
+  }
+
  private:
   // Descriptor struct used to hold information about registered MDPs. It is
   // deliberately copyable, in order to allow to be used as hash_map value.
   struct MemoryDumpProviderInfo {
     MemoryDumpProviderInfo(
         const scoped_refptr<SingleThreadTaskRunner>& task_runner);
     ~MemoryDumpProviderInfo();
 
     scoped_refptr<SingleThreadTaskRunner> task_runner;  // Optional.
     int consecutive_failures;  // Number of times the provider failed (to
@@ skipping 20 matching lines @@
   // thread on which CreateProcessDump() was called.
   void CreateProcessDump(const MemoryDumpRequestArgs& args,
                          const MemoryDumpCallback& callback);
 
   bool InvokeDumpProviderLocked(MemoryDumpProvider* mdp,
                                 ProcessMemoryDump* pmd);
   void ContinueAsyncProcessDump(
       MemoryDumpProvider* mdp,
       scoped_refptr<ProcessMemoryDumpHolder> pmd_holder);
 
+  // Pass kInvalidTracingProcessId for invalidating the id.
+  void set_tracing_process_id(int id) {
+    DCHECK(tracing_process_id_ == kInvalidTracingProcessId ||
+           id == kInvalidTracingProcessId);
+    tracing_process_id_ = id;
+  }
+
   hash_map<MemoryDumpProvider*, MemoryDumpProviderInfo> dump_providers_;
 
   // Shared among all the PMDs to keep state scoped to the tracing session.
   scoped_refptr<MemoryDumpSessionState> session_state_;
 
   MemoryDumpManagerDelegate* delegate_;  // Not owned.
 
   // Protects from concurrent accesses to the |dump_providers_*| and |delegate_|
   // to guard against disabling logging while dumping on another thread.
   Lock lock_;
 
   // Optimization to avoid attempting any memory dump (i.e. to not walk an empty
   // dump_providers_enabled_ list) when tracing is not enabled.
   subtle::AtomicWord memory_tracing_enabled_;
 
   // For time-triggered periodic dumps.
   RepeatingTimer<MemoryDumpManager> periodic_dump_timer_;
 
+  // The unique id of the child process. This is created only for tracing and is
+  // expected to be valid only when tracing is enabled.
+  int tracing_process_id_;
+
   // Skips the auto-registration of the core dumpers during Initialize().
   bool skip_core_dumpers_auto_registration_for_testing_;
 
   DISALLOW_COPY_AND_ASSIGN(MemoryDumpManager);
 };
 
 // The delegate is supposed to be long lived (read: a Singleton) and thread
 // safe (i.e. should expect calls from any thread and handle thread hopping).
 class BASE_EXPORT MemoryDumpManagerDelegate {
  public:
   virtual void RequestGlobalMemoryDump(const MemoryDumpRequestArgs& args,
                                        const MemoryDumpCallback& callback) = 0;
 
   // Determines whether the MemoryDumpManager instance should be the master
   // (the ones which initiates and coordinates the multiprocess dumps) or not.
   virtual bool IsCoordinatorProcess() const = 0;
 
  protected:
   MemoryDumpManagerDelegate() {}
   virtual ~MemoryDumpManagerDelegate() {}
 
   void CreateProcessDump(const MemoryDumpRequestArgs& args,
                          const MemoryDumpCallback& callback) {
     MemoryDumpManager::GetInstance()->CreateProcessDump(args, callback);
   }
 
+  void set_tracing_process_id(int id) {
+    MemoryDumpManager::GetInstance()->set_tracing_process_id(id);
+  }
+
  private:
   DISALLOW_COPY_AND_ASSIGN(MemoryDumpManagerDelegate);
 };
 
 }  // namespace trace_event
 }  // namespace base
 
 #endif  // BASE_TRACE_EVENT_MEMORY_DUMP_MANAGER_H_