Move content's shell connections to the IO thread

services/shell/public/cpp/interface_registry.h

 // Copyright 2016 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_SHELL_PUBLIC_CPP_INTERFACE_REGISTRY_H_
 #define SERVICES_SHELL_PUBLIC_CPP_INTERFACE_REGISTRY_H_
 
 #include <memory>
+#include <queue>
+#include <utility>
 
+#include "base/callback.h"
 #include "base/memory/ptr_util.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "services/shell/public/cpp/lib/callback_binder.h"
 #include "services/shell/public/cpp/lib/interface_factory_binder.h"
 #include "services/shell/public/interfaces/interface_provider.mojom.h"
 
 namespace shell {
 class InterfaceBinder;
 
 // An implementation of mojom::InterfaceProvider that allows the user to
@@ skipping 13 matching lines @@
 //
 // The InterfaceFactory must outlive the InterfaceRegistry.
 //
 // Additionally you may specify a default InterfaceBinder to handle requests for
 // interfaces unhandled by any registered InterfaceFactory. Just as with
 // InterfaceFactory, the default InterfaceBinder supplied must outlive
 // InterfaceRegistry.
 //
 class InterfaceRegistry : public mojom::InterfaceProvider {
  public:
+  using Binder = base::Callback<void(const mojo::String&,
+                                     mojo::ScopedMessagePipeHandle)>;
+
   class TestApi {
    public:
     explicit TestApi(InterfaceRegistry* registry) : registry_(registry) {}
     ~TestApi() {}
 
     void SetInterfaceBinderForName(InterfaceBinder* binder,
                                    const std::string& interface_name) {
       registry_->SetInterfaceBinderForName(
           base::WrapUnique(binder), interface_name);
     }
 
    private:
     InterfaceRegistry* registry_;
     DISALLOW_COPY_AND_ASSIGN(TestApi);
   };
 
   // Construct with a Connection (which may be null), and create an
   // InterfaceProvider pipe, the client end of which may be obtained by calling
   // TakeClientHandle(). If |connection| is non-null, the Mojo Shell's
   // rules filtering which interfaces are allowed to be exposed to clients are
   // imposed on this registry. If null, they are not.
   explicit InterfaceRegistry(Connection* connection);
   ~InterfaceRegistry() override;
 
+  // Sets a default handler for incoming interface requests which are allowed by
+  // capability filters but have no registered handler in this registry.
+  void set_default_binder(const Binder& binder) { default_binder_ = binder; }
+
   void Bind(mojom::InterfaceProviderRequest local_interfaces_request);
 
   base::WeakPtr<InterfaceRegistry> GetWeakPtr();
 
   // Allows |Interface| to be exposed via this registry. Requests to bind will
   // be handled by |factory|. Returns true if the interface was exposed, false
   // if Connection policy prevented exposure.
   template <typename Interface>
   bool AddInterface(InterfaceFactory<Interface>* factory) {
     return SetInterfaceBinderForName(
@@ skipping 48 matching lines @@
   bool SetInterfaceBinderForName(std::unique_ptr<InterfaceBinder> binder,
                                  const std::string& name);
 
   mojom::InterfaceProviderRequest pending_request_;
 
   mojo::Binding<mojom::InterfaceProvider> binding_;
   Connection* connection_;
 
   NameToInterfaceBinderMap name_to_binder_;
 
+  Binder default_binder_;
+
+  bool is_paused_ = false;
+
+  // Pending interface requests which can accumulate if GetInterface() is called
+  // while binding is paused.
+  std::queue<std::pair<mojo::String, mojo::ScopedMessagePipeHandle>>
+      pending_interface_requests_;
+
   base::WeakPtrFactory<InterfaceRegistry> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(InterfaceRegistry);
 };
 
 }  // namespace shell
 
 #endif  // SERVICES_SHELL_PUBLIC_CPP_INTERFACE_REGISTRY_H_