Mojo C++ bindings: remove usage of AssociatedGroup from ipc/

ipc/ipc_channel_proxy.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 IPC_IPC_CHANNEL_PROXY_H_
 #define IPC_IPC_CHANNEL_PROXY_H_
 
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/non_thread_safe.h"
 #include "build/build_config.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_channel_handle.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_sender.h"
-#include "mojo/public/cpp/bindings/associated_group.h"
 #include "mojo/public/cpp/bindings/associated_interface_ptr.h"
 #include "mojo/public/cpp/bindings/associated_interface_request.h"
 #include "mojo/public/cpp/bindings/scoped_interface_endpoint_handle.h"
 #include "mojo/public/cpp/bindings/thread_safe_interface_ptr.h"
 
 namespace base {
 class SingleThreadTaskRunner;
 }
 
 namespace IPC {
@@ skipping 145 matching lines @@
   // Init().
   template <typename Interface>
   void AddAssociatedInterfaceForIOThread(
       const AssociatedInterfaceFactory<Interface>& factory) {
     AddGenericAssociatedInterfaceForIOThread(
         Interface::Name_,
         base::Bind(&ChannelProxy::BindAssociatedInterfaceRequest<Interface>,
                    factory));
   }
 
-  // Gets the AssociatedGroup used to create new associated endpoints on this
-  // ChannelProxy.
-  mojo::AssociatedGroup* GetAssociatedGroup();
-
   // Requests an associated interface from the remote endpoint.
   void GetGenericRemoteAssociatedInterface(
       const std::string& name,
       mojo::ScopedInterfaceEndpointHandle handle);
 
   // Template helper to request associated interfaces from the remote endpoint.
   template <typename Interface>
   void GetRemoteAssociatedInterface(
       mojo::AssociatedInterfacePtr<Interface>* proxy) {
-    mojo::AssociatedInterfaceRequest<Interface> request =
-        mojo::MakeRequest(proxy, GetAssociatedGroup());
+    auto request = mojo::MakeRequest(proxy);
     GetGenericRemoteAssociatedInterface(Interface::Name_, request.PassHandle());
   }
 
 #if defined(ENABLE_IPC_FUZZER)
   void set_outgoing_message_filter(OutgoingMessageFilter* filter) {
     outgoing_message_filter_ = filter;
   }
 #endif
 
   // Creates a ThreadSafeAssociatedInterfacePtr for |Interface|. This object
   // may be used to send messages on the interface from any thread and those
   // messages will remain ordered with respect to other messages sent on the
   // same thread over other ThreadSafeAssociatedInterfacePtrs associated with
   // the same Channel.
   template <typename Interface>
   void GetThreadSafeRemoteAssociatedInterface(
       scoped_refptr<mojo::ThreadSafeAssociatedInterfacePtr<Interface>>*
           out_ptr) {
     mojo::AssociatedInterfacePtrInfo<Interface> ptr_info;
-    mojo::AssociatedInterfaceRequest<Interface> request;
-    GetAssociatedGroup()->CreateAssociatedInterface(
-        mojo::AssociatedGroup::WILL_PASS_REQUEST, &ptr_info, &request);
+    auto request = mojo::MakeRequest(&ptr_info);
     GetGenericRemoteAssociatedInterface(Interface::Name_, request.PassHandle());
     *out_ptr = mojo::ThreadSafeAssociatedInterfacePtr<Interface>::Create(
         std::move(ptr_info), ipc_task_runner());
   }
 
   base::SingleThreadTaskRunner* ipc_task_runner() const {
     return context_->ipc_task_runner();
   }
 
   // Called to clear the pointer to the IPC task runner when it's going away.
@@ skipping 69 matching lines @@
     void AddFilter(MessageFilter* filter);
     void OnDispatchConnected();
     void OnDispatchError();
     void OnDispatchBadMessage(const Message& message);
     void OnDispatchAssociatedInterfaceRequest(
         const std::string& interface_name,
         mojo::ScopedInterfaceEndpointHandle handle);
 
     void ClearChannel();
 
-    mojo::AssociatedGroup* associated_group() { return &associated_group_; }
     mojom::Channel& thread_safe_channel() {
       return thread_safe_channel_->proxy();
     }
 
     void AddGenericAssociatedInterfaceForIOThread(
         const std::string& name,
         const GenericAssociatedInterfaceFactory& factory);
 
     scoped_refptr<base::SingleThreadTaskRunner> listener_task_runner_;
     Listener* listener_;
@@ skipping 21 matching lines @@
     // IPC thread when they're added to filters_.
     std::vector<scoped_refptr<MessageFilter> > pending_filters_;
     // Lock for pending_filters_.
     base::Lock pending_filters_lock_;
 
     // Cached copy of the peer process ID. Set on IPC but read on both IPC and
     // listener threads.
     base::ProcessId peer_pid_;
     base::Lock peer_pid_lock_;
 
-    mojo::AssociatedGroup associated_group_;
-
     // A thread-safe mojom::Channel interface we use to make remote interface
     // requests from the proxy thread.
     std::unique_ptr<mojo::ThreadSafeForwarder<mojom::Channel>>
         thread_safe_channel_;
 
     // Holds associated interface binders added by
     // AddGenericAssociatedInterfaceForIOThread until the underlying channel has
     // been initialized.
     base::Lock pending_io_thread_interfaces_lock_;
     std::vector<std::pair<std::string, GenericAssociatedInterfaceFactory>>
@@ skipping 35 matching lines @@
   bool did_init_;
 
 #if defined(ENABLE_IPC_FUZZER)
   OutgoingMessageFilter* outgoing_message_filter_;
 #endif
 };
 
 }  // namespace IPC
 
 #endif  // IPC_IPC_CHANNEL_PROXY_H_