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

content/public/test/mock_render_process_host.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_PUBLIC_TEST_MOCK_RENDER_PROCESS_HOST_H_
 #define CONTENT_PUBLIC_TEST_MOCK_RENDER_PROCESS_HOST_H_
 
 #include <stddef.h>
 #include <stdint.h>
 #include <utility>
 
 #include "base/macros.h"
 #include "base/memory/scoped_vector.h"
+#include "base/metrics/persistent_memory_allocator.h"
 #include "base/observer_list.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_process_host_factory.h"
 #include "content/public/common/service_registry.h"
 #include "ipc/ipc_test_sink.h"
 
 class StoragePartition;
 
 namespace content {
 
@@ skipping 61 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& zone_id) override;
   ServiceRegistry* GetServiceRegistry() override;
+  scoped_ptr<base::SharedPersistentMemoryAllocator> GetMetricsAllocator()
+      override;

[Alexei Svitkine (slow), 2016/03/24 17:29:53]

I think it's pretty strange for the function to be called Get*() but for it to
transfer ownership. Please use a different name that makes it clear that
ownership is being transferred and document the use case in the comment for this
function in the interface.

[bcwhite, 2016/03/29 11:53:27]

Done.

   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 28 matching lines @@
 
   void GetAudioOutputControllers(
       const GetAudioOutputControllersCallback& callback) const override {}
 
   int worker_ref_count() const { return worker_ref_count_; }
 
   void SetServiceRegistry(scoped_ptr<ServiceRegistry> service_registry) {
     service_registry_ = std::move(service_registry);
   }
 
+  void SetMetricsAllocator(

[Alexei Svitkine (slow), 2016/03/24 17:29:53]

What calls this?

[bcwhite, 2016/03/29 11:53:27]

Nothing.  But since it's a mock and allows extraction of the allocator, it
seemed a good idea to add a method to inject it.

[Alexei Svitkine (slow), 2016/03/29 17:51:24]

I don't think we should add it if it's not needed. If it becomes needed, it can
be added by the CL that needs it. Also, you can remove the member variable as
well and make the getter return null.

[bcwhite, 2016/03/30 21:25:55]

Done.

+      scoped_ptr<base::SharedPersistentMemoryAllocator> allocator) {
+    metrics_allocator_ = std::move(allocator);
+  }
+
  private:
   // Stores IPC messages that would have been sent to the renderer.
   IPC::TestSink sink_;
   int bad_msg_count_;
   const MockRenderProcessHostFactory* factory_;
   int id_;
   bool has_connection_;
   BrowserContext* browser_context_;
   base::ObserverList<RenderProcessHostObserver> observers_;
 
   IDMap<RenderWidgetHost> render_widget_hosts_;
   int prev_routing_id_;
   IDMap<IPC::Listener> listeners_;
   bool fast_shutdown_started_;
   bool deletion_callback_called_;
   bool is_for_guests_only_;
   bool is_process_backgrounded_;
   scoped_ptr<base::ProcessHandle> process_handle;
   int worker_ref_count_;
   scoped_ptr<ServiceRegistry> service_registry_;
+  scoped_ptr<base::SharedPersistentMemoryAllocator> metrics_allocator_;
 
   DISALLOW_COPY_AND_ASSIGN(MockRenderProcessHost);
 };
 
 class MockRenderProcessHostFactory : public RenderProcessHostFactory {
  public:
   MockRenderProcessHostFactory();
   ~MockRenderProcessHostFactory() override;
 
   RenderProcessHost* CreateRenderProcessHost(
@@ skipping 10 matching lines @@
   // for deleting all MockRenderProcessHosts that have not deleted by a test in
   // the destructor and prevent them from being leaked.
   mutable ScopedVector<MockRenderProcessHost> processes_;
 
   DISALLOW_COPY_AND_ASSIGN(MockRenderProcessHostFactory);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_PUBLIC_TEST_MOCK_RENDER_PROCESS_HOST_H_