Remove OwnedInterface

content/public/browser/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_BROWSER_RENDER_PROCESS_HOST_H_
 #define CONTENT_PUBLIC_BROWSER_RENDER_PROCESS_HOST_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <list>
 
 #include "base/id_map.h"
 #include "base/memory/ptr_util.h"
 #include "base/process/kill.h"
 #include "base/process/process_handle.h"
 #include "base/supports_user_data.h"
 #include "content/common/content_export.h"
-#include "content/public/browser/owned_interface.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_sender.h"
 #include "services/shell/public/cpp/interface_registry.h"
 #include "ui/gfx/native_widget_types.h"
 
 class GURL;
 
 namespace base {
 class SharedPersistentMemoryAllocator;
 class TimeDelta;
 }
 
 namespace media {
 class AudioOutputController;
 class MediaKeys;
 }
 
 namespace shell {
 class Connection;
 class InterfaceProvider;
 }
 
 namespace content {
 class BrowserContext;
 class BrowserMessageFilter;
-class OwnedInterface;
 class RenderProcessHostObserver;
 class RenderWidgetHost;
 class StoragePartition;
 struct GlobalRequestID;
 
 // Interface that represents the browser side of the browser <-> renderer
 // communication channel. There will generally be one RenderProcessHost per
 // renderer process.
 class CONTENT_EXPORT RenderProcessHost : public IPC::Sender,
                                          public IPC::Listener,
@@ skipping 122 matching lines @@
   // Call this to allow queueing of IPC messages that are sent before the
   // process is launched.
   virtual void EnableSendQueue() = 0;
 
   // Returns the renderer channel.
   virtual IPC::ChannelProxy* GetChannel() = 0;
 
   // Adds a message filter to the IPC channel.
   virtual void AddFilter(BrowserMessageFilter* filter) = 0;
 
-  // Adds an interface impl which will be owned by this host and registered in
-  // its interface registry. Requests to bind will be handled by calling
-  // |callback|, which must be a member function on |impl|. The method referred
-  // to by |Callback| must conform to the signature `void fun(MyInterfaceRequest
-  // request)`.
-  //
-  // New connections and incoming messages will be dispatched on |task_runner|
-  // (or on the current task runner if not specified). The impl will also be
-  // deleted on |task_runner|.
-  template <typename InterfaceImpl, typename Callback>
-  void AddOwnedInterface(std::unique_ptr<InterfaceImpl> impl,
-                         Callback callback,
-                         const scoped_refptr<base::SingleThreadTaskRunner>&
-                             task_runner = nullptr) {
-    auto owned = base::MakeUnique<content::OwnedInterfaceImpl<InterfaceImpl>>(
-        std::move(impl), task_runner);
-    GetInterfaceRegistry()->AddInterface(
-        base::Bind(callback, base::Unretained(owned->get())), task_runner);
-    AddOwnedInterface(std::move(owned));
-  }
-
-  // Adds the |impl| to the collection of interface impls owned by this
-  // host. The impl must be registered separately using
-  // |GetInterfaceRegistry()|. This function is useful if a single object is
-  // used to implement several interfaces.
-  //
-  // Implementation of |AddOwnedInterface()| must guarantee that the added impls
-  // outlive the |InterfaceRegistry| returned by |GetInterfaceRegistry()|.
-  virtual void AddOwnedInterface(std::unique_ptr<OwnedInterface> impl) = 0;
-
   // Try to shutdown the associated render process as fast as possible
   virtual bool FastShutdownForPageCount(size_t count) = 0;
 
   // TODO(ananta)
   // Revisit whether the virtual functions declared from here on need to be
   // part of the interface.
   virtual void SetIgnoreInputEvents(bool ignore_input_events) = 0;
   virtual bool IgnoreInputEvents() const = 0;
 
   // Schedules the host for deletion and removes it from the all_hosts list.
@@ skipping 173 matching lines @@
   static void SetMaxRendererProcessCount(size_t count);
 
   // Returns the current maximum number of renderer process hosts kept by the
   // content module.
   static size_t GetMaxRendererProcessCount();
 };
 
 }  // namespace content.
 
 #endif  // CONTENT_PUBLIC_BROWSER_RENDER_PROCESS_HOST_H_