Create and pass shared-histogram-allocator from browser to renderer.

content/browser/renderer_host/render_process_host_impl.h

 // Copyright (c) 2012 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 CONTENT_BROWSER_RENDERER_HOST_RENDER_PROCESS_HOST_IMPL_H_
 #define CONTENT_BROWSER_RENDERER_HOST_RENDER_PROCESS_HOST_IMPL_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 137 matching lines @@
   void SetWebRtcLogMessageCallback(
       base::Callback<void(const std::string&)> callback) override;
   WebRtcStopRtpDumpCallback StartRtpDump(
       bool incoming,
       bool outgoing,
       const WebRtcRtpPacketCallback& packet_callback) override;
 #endif
   void ResumeDeferredNavigation(const GlobalRequestID& request_id) override;
   void NotifyTimezoneChange(const std::string& timezone) override;
   ServiceRegistry* GetServiceRegistry() override;
+  scoped_ptr<base::SharedPersistentMemoryAllocator> ExtractMetricsAllocator()
+      override;
   const base::TimeTicks& GetInitTimeForNavigationMetrics() const override;
   bool SubscribeUniformEnabled() const override;
   void OnAddSubscription(unsigned int target) override;
   void OnRemoveSubscription(unsigned int target) override;
   void SendUpdateValueState(
       unsigned int target, const gpu::ValueState& state) override;
 #if defined(ENABLE_BROWSER_CDMS)
   scoped_refptr<media::MediaKeys> GetCdm(int render_frame_id,
                                          int cdm_id) const override;
 #endif
@@ skipping 153 matching lines @@
   // copied over.
   void PropagateBrowserCommandLineToRenderer(
       const base::CommandLine& browser_cmd,
       base::CommandLine* renderer_cmd) const;
 
   // Inspects the current object state and sets/removes background priority if
   // appropriate. Should be called after any of the involved data members
   // change.
   void UpdateProcessPriority();
 
+  // Creates a PersistentMemoryAllocator and shares it with the renderer
+  // process for it to store histograms from that process. The allocator is
+  // available for extraction by a SubprocesMetricsProvider in order to
+  // report those histograms to UMA.
+  void CreateSharedRendererHistogramAllocator();
+
   // Handle termination of our process.
   void ProcessDied(bool already_dead, RendererClosedDetails* known_details);
 
   // GpuSwitchingObserver implementation.
   void OnGpuSwitched() override;
 
 #if defined(ENABLE_WEBRTC)
   void OnRegisterAecDumpConsumer(int id);
   void OnRegisterEventLogConsumer(int id);
   void OnUnregisterAecDumpConsumer(int id);
@@ skipping 157 matching lines @@
   SubscriptionSet subscription_set_;
 
   // Maintains ValueStates which are not currently subscribed too so we can
   // pass them to the GpuService if a Valuebuffer ever subscribes to the
   // respective subscription target
   scoped_refptr<gpu::ValueStateMap> pending_valuebuffer_state_;
 
   // Whether or not the CHROMIUM_subscribe_uniform WebGL extension is enabled
   bool subscribe_uniform_enabled_;
 
+  // The memory allocator, if any, in which the renderer will write its metrics.
+  scoped_ptr<base::SharedPersistentMemoryAllocator> metrics_allocator_;
+
   bool channel_connected_;
   bool sent_render_process_ready_;
 
 #if defined(OS_ANDROID)
   // UI thread is the source of sync IPCs and all shutdown signals.
   // Therefore a proper shutdown event to unblock the UI thread is not
   // possible without massive refactoring shutdown code.
   // Luckily Android never performs a clean shutdown. So explicitly
   // ignore this problem.
   base::WaitableEvent never_signaled_;
 #endif
 
   std::string mojo_channel_token_;
   mojo::ScopedMessagePipeHandle in_process_renderer_handle_;
 
   base::WeakPtrFactory<RenderProcessHostImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderProcessHostImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_RENDER_PROCESS_HOST_IMPL_H_