[Memory-UMA] Implement basic working prototype.

services/resource_coordinator/memory/coordinator/coordinator_impl.h

 // 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.
 
 #ifndef SERVICES_RESOURCE_COORDINATOR_MEMORY_COORDINATOR_COORDINATOR_IMPL_H_
 #define SERVICES_RESOURCE_COORDINATOR_MEMORY_COORDINATOR_COORDINATOR_IMPL_H_
 
 #include <list>
 #include <map>
 #include <set>
 
 #include "base/memory/ref_counted.h"
 #include "base/threading/thread_checker.h"
 #include "base/trace_event/memory_dump_request_args.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/bindings/binding_set.h"
+#include "services/resource_coordinator/memory/coordinator/process_map.h"
 #include "services/resource_coordinator/public/cpp/memory/coordinator.h"
 #include "services/resource_coordinator/public/interfaces/memory/memory_instrumentation.mojom.h"
 
+namespace service_manager {
+class Connector;
+}
+
 namespace memory_instrumentation {
 
 class CoordinatorImpl : public Coordinator, public mojom::Coordinator {
  public:
   // The getter of the unique instance.
   static CoordinatorImpl* GetInstance();
 
-  explicit CoordinatorImpl(bool initialize_memory_dump_manager);
+  CoordinatorImpl(bool initialize_memory_dump_manager,
+                  service_manager::Connector* connector,
+                  bool initialize_process_map);

[Primiano Tucci (use gerrit), 2017/05/15 03:48:10]

don't see a strong need for this |initialize_process_map| (see the other comment
in the cc file)

[erikchen, 2017/05/15 17:29:15]

Done.

 
   // Coordinator
   void BindCoordinatorRequest(
       const service_manager::BindSourceInfo& source_info,
       mojom::CoordinatorRequest) override;
 
   bool initialize_memory_dump_manager() const {
     return initialize_memory_dump_manager_;
   }
 
+ protected:
+  // virtual for testing.
+  virtual service_manager::Identity GetDispatchContext() const;
+  ~CoordinatorImpl() override;
+
  private:
   friend std::default_delete<CoordinatorImpl>;  // For testing
   friend class CoordinatorImplTest;             // For testing
 
   struct QueuedMemoryDumpRequest {
     QueuedMemoryDumpRequest(const base::trace_event::MemoryDumpRequestArgs args,
                             const RequestGlobalMemoryDumpCallback callback);
     ~QueuedMemoryDumpRequest();
     const base::trace_event::MemoryDumpRequestArgs args;
     const RequestGlobalMemoryDumpCallback callback;
 
     // Collects the data received from OnProcessMemoryDumpResponse().
-    std::vector<mojom::ProcessMemoryDumpPtr> process_memory_dumps;
+    std::vector<std::pair<base::ProcessId, mojom::ProcessMemoryDumpPtr>>
+        process_memory_dumps;
   };
 
-  ~CoordinatorImpl() override;
+  using ProcessLocalDumpManagerEntry =
+      std::pair<mojom::ProcessLocalDumpManagerPtr, service_manager::Identity>;

[Primiano Tucci (use gerrit), 2017/05/15 03:48:09]

this will:

1) make the code in the .cc file full of .first.second which are unreadable
2) make it so that both the map will have to deep move all the identity objects
over and over, on each rebalance operation. Identity has bunch of strings.
I'd:

- Create a struct which has fields, something like:

  struct ClientEndpoint {
    ClientEndpoint(service_manager::Identity,
                   mojom::ProcessLocalDumpManagerPtr);
    ~ClientEndpoint();

    const service_manager::Identity identity;
    const mojom::ProcessLocalDumpManagerPtr remote;
  };

use a map<PLMD*, std::unique_ptr<ClientEndpoint>> below 

[Primiano Tucci (use gerrit), 2017/05/15 16:35:05]

discussed offline, I have a patch to clean this later, so ignore this comment.

 
   // mojom::Coordinator
   void RegisterProcessLocalDumpManager(
       mojom::ProcessLocalDumpManagerPtr process_manager) override;
 
   // Broadcasts a dump request to all the process-local managers registered and
   // notifies when all of them have completed, or the global dump attempt
   // failed. This is in the mojom::Coordinator interface.
   void RequestGlobalMemoryDump(
       const base::trace_event::MemoryDumpRequestArgs& args,
       const RequestGlobalMemoryDumpCallback& callback) override;
 
   // Called when a process-local manager gets disconnected.
   void UnregisterProcessLocalDumpManager(
       mojom::ProcessLocalDumpManager* process_manager);
 
   // Callback of RequestProcessMemoryDump.
   void OnProcessMemoryDumpResponse(
       mojom::ProcessLocalDumpManager* process_manager,
       uint64_t dump_guid,
       bool success,
       mojom::ProcessMemoryDumpPtr process_memory_dump);
 
   void PerformNextQueuedGlobalMemoryDump();
   void FinalizeGlobalMemoryDumpIfAllManagersReplied();
+  void InitProcessMap(service_manager::Connector* connector);
 
-  mojo::BindingSet<mojom::Coordinator> bindings_;
+  mojo::BindingSet<mojom::Coordinator, service_manager::Identity> bindings_;
 
   // Registered ProcessLocalDumpManagers.
-  std::map<mojom::ProcessLocalDumpManager*, mojom::ProcessLocalDumpManagerPtr>
+  std::map<mojom::ProcessLocalDumpManager*, ProcessLocalDumpManagerEntry>
       process_managers_;
 
   // Pending process managers for RequestGlobalMemoryDump.
   std::set<mojom::ProcessLocalDumpManager*> pending_process_managers_;
   int failed_memory_dump_count_;
   std::list<QueuedMemoryDumpRequest> queued_memory_dump_requests_;
 
   const bool initialize_memory_dump_manager_;
 
   base::ThreadChecker thread_checker_;
 
+  std::unique_ptr<ProcessMap> process_map_;
+
   DISALLOW_COPY_AND_ASSIGN(CoordinatorImpl);
 };
 
 }  // namespace memory_instrumentation
 #endif  // SERVICES_RESOURCE_COORDINATOR_MEMORY_COORDINATOR_COORDINATOR_IMPL_H_