Adds BrowserAssociatedInterface

content/public/browser/browser_message_filter.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_BROWSER_BROWSER_MESSAGE_FILTER_H_
 #define CONTENT_PUBLIC_BROWSER_BROWSER_MESSAGE_FILTER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 #include <utility>
@@ skipping 11 matching lines @@
 
 namespace base {
 class TaskRunner;
 }
 
 namespace IPC {
 class MessageFilter;
 }
 
 namespace content {
+class BrowserAssociatedInterfaceTest;
 struct BrowserMessageFilterTraits;
 
 // Base class for message filters in the browser process.  You can receive and
 // send messages on any thread.
 class CONTENT_EXPORT BrowserMessageFilter
     : public base::RefCountedThreadSafe<
           BrowserMessageFilter, BrowserMessageFilterTraits>,
       public IPC::Sender {
  public:
   explicit BrowserMessageFilter(uint32_t message_class_to_filter);
@@ skipping 33 matching lines @@
   // since that has extra checks to avoid deadlocks.
   virtual base::TaskRunner* OverrideTaskRunnerForMessage(
       const IPC::Message& message);
 
   // Override this to receive messages.
   // Your function will normally be called on the IO thread.  However, if your
   // OverrideXForMessage modifies the thread used to dispatch the message,
   // your function will be called on the requested thread.
   virtual bool OnMessageReceived(const IPC::Message& message) = 0;
 
+  // Adds an associated interface factory to this filter. Must be called before
+  // RegisterAssociatedInterfaces().
+  void AddAssociatedInterface(
+      const std::string& name,
+      const IPC::ChannelProxy::GenericAssociatedInterfaceFactory& factory);
+
   // Can be called on any thread, after OnChannelConnected is called.
   base::ProcessHandle PeerHandle();
 
   // Can be called on any thread, after OnChannelConnected is called.
   base::ProcessId peer_pid() const { return peer_process_.Pid(); }
 
   void set_peer_process_for_testing(base::Process peer_process) {
     peer_process_ = std::move(peer_process);
   }
 
   // Called by bad_message.h helpers if a message couldn't be deserialized. This
   // kills the renderer.  Can be called on any thread.  This doesn't log the
   // error details to UMA, so use the bad_message.h for your module instead.
   virtual void ShutdownForBadMessage();
 
   const std::vector<uint32_t>& message_classes_to_filter() const {
     return message_classes_to_filter_;
   }
 
  protected:
   ~BrowserMessageFilter() override;
 
  private:
   friend class base::RefCountedThreadSafe<BrowserMessageFilter,
                                           BrowserMessageFilterTraits>;
 
   class Internal;
+  friend class BrowserAssociatedInterfaceTest;
   friend class BrowserChildProcessHostImpl;
   friend class BrowserPpapiHost;
   friend class RenderProcessHostImpl;
 
-  // This is private because the only classes that need access to it are made
-  // friends above. This is only guaranteed to be valid on creation, after that
-  // this class could outlive the filter.
+  // These are private because the only classes that need access to them are
+  // made friends above. These are only guaranteed to be valid to call on
+  // creation. After that this class could outlive the filter and new interface
+  // registrations could race with incoming requests.
   IPC::MessageFilter* GetFilter();
+  void RegisterAssociatedInterfaces(IPC::ChannelProxy* proxy);
 
   // This implements IPC::MessageFilter so that we can hide that from child
   // classes. Internal keeps a reference to this class, which is why there's a
   // weak pointer back. This class could outlive Internal based on what the
   // child class does in its OnDestruct method.
   Internal* internal_;
 
   IPC::Sender* sender_;
   base::Process peer_process_;
 
   std::vector<uint32_t> message_classes_to_filter_;
+
+  std::vector<std::pair<std::string,
+                        IPC::ChannelProxy::GenericAssociatedInterfaceFactory>>
+      associated_interfaces_;
 };
 
 struct BrowserMessageFilterTraits {
   static void Destruct(const BrowserMessageFilter* filter) {
     filter->OnDestruct();
   }
 };
 
 }  // namespace content
 
 #endif  // CONTENT_PUBLIC_BROWSER_BROWSER_MESSAGE_FILTER_H_