text: // Copyright 2017 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 EXTENSIONS_RENDERER_IPC_MESSAGE_SENDER_H_
  #define EXTENSIONS_RENDERER_IPC_MESSAGE_SENDER_H_
  
  #include "base/macros.h"
  
  #include <memory>
  #include <string>
  
  #include "extensions/renderer/bindings/api_binding_types.h"
  
  struct ExtensionHostMsg_Request_Params;
  
  namespace base {
  class DictionaryValue;
  }
  
  namespace extensions {
  class ScriptContext;
  class WorkerThreadDispatcher;
  struct Message;
  struct MessageTarget;
  struct PortId;
  
  // A class to handle sending bindings-related messages to the browser. Different
  // versions handle main thread vs. service worker threads.
  class IPCMessageSender {
   public:
    virtual ~IPCMessageSender();
  
    // Sends a request message to the browser.
    virtual void SendRequestIPC(
        ScriptContext* context,
        std::unique_ptr<ExtensionHostMsg_Request_Params> params) = 0;
  
    // Handles sending any additional messages required after receiving a response
    // to a request.
    virtual void SendOnRequestResponseReceivedIPC(int request_id) = 0;
  
    // Sends a message to add/remove an unfiltered listener.
    virtual void SendAddUnfilteredEventListenerIPC(
        ScriptContext* context,
        const std::string& event_name) = 0;
    virtual void SendRemoveUnfilteredEventListenerIPC(
        ScriptContext* context,
        const std::string& event_name) = 0;
  
    // Sends a message to add/remove a lazy unfiltered listener.
    virtual void SendAddUnfilteredLazyEventListenerIPC(
        ScriptContext* context,
        const std::string& event_name) = 0;
    virtual void SendRemoveUnfilteredLazyEventListenerIPC(
        ScriptContext* context,
        const std::string& event_name) = 0;
  
    // Sends a message to add/remove a filtered listener.
    virtual void SendAddFilteredEventListenerIPC(
        ScriptContext* context,
        const std::string& event_name,
        const base::DictionaryValue& filter,
        bool is_lazy) = 0;
    virtual void SendRemoveFilteredEventListenerIPC(
        ScriptContext* context,
        const std::string& event_name,
        const base::DictionaryValue& filter,
        bool remove_lazy_listener) = 0;
  
    // Opens a message channel to the specified target.
    virtual void SendOpenMessageChannel(ScriptContext* script_context,
                                        const PortId& port_id,
                                        const MessageTarget& target,
                                        const std::string& channel_name) = 0;
  
    // Sends a message to open/close a mesage port or send a message to an
    // existing port.
    virtual void SendOpenMessagePort(int routing_id, const PortId& port_id) = 0;
    virtual void SendCloseMessagePort(int routing_id,
                                      const PortId& port_id,
                                      bool close_channel) = 0;
    virtual void SendPostMessageToPort(const PortId& port_id,
                                       const Message& message) = 0;
  
    // Creates an IPCMessageSender for use on the main thread.
    static std::unique_ptr<IPCMessageSender> CreateMainThreadIPCMessageSender();
  
    // Creates an IPCMessageSender for use on a worker thread.
    static std::unique_ptr<IPCMessageSender> CreateWorkerThreadIPCMessageSender(
        WorkerThreadDispatcher* dispatcher,
        int64_t service_worker_version_id);
  
   protected:
    IPCMessageSender();
  
    DISALLOW_COPY_AND_ASSIGN(IPCMessageSender);
  };
  
  }  // namespace extensions
  
  #endif  // EXTENSIONS_RENDERER_IPC_MESSAGE_SENDER_H_
  