Revert "Port WebSockets to Mojo IPC"

content/browser/renderer_host/websocket_dispatcher_host.h

Index: content/browser/renderer_host/websocket_dispatcher_host.h
diff --git a/content/browser/renderer_host/websocket_dispatcher_host.h b/content/browser/renderer_host/websocket_dispatcher_host.h
new file mode 100644
index 0000000000000000000000000000000000000000..5d5c804ddf3e98edb607403c52b889fada6560da
--- /dev/null
+++ b/content/browser/renderer_host/websocket_dispatcher_host.h
@@ -0,0 +1,212 @@
+// Copyright 2013 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_BROWSER_RENDERER_HOST_WEBSOCKET_DISPATCHER_HOST_H_
+#define CONTENT_BROWSER_RENDERER_HOST_WEBSOCKET_DISPATCHER_HOST_H_
+
+#include <stdint.h>
+#include <string>
+#include <vector>
+
+#include "base/callback.h"
+#include "base/compiler_specific.h"
+#include "base/containers/hash_tables.h"
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "base/time/time.h"
+#include "base/timer/timer.h"
+#include "content/common/content_export.h"
+#include "content/common/websocket.h"
+#include "content/public/browser/browser_message_filter.h"
+
+namespace net {
+class URLRequestContext;
+}  // namespace net
+
+namespace storage {
+class BlobStorageContext;
+}
+
+namespace content {
+
+class ChromeBlobStorageContext;
+class StoragePartition;
+struct WebSocketHandshakeRequest;
+struct WebSocketHandshakeResponse;
+class WebSocketHost;
+
+// Creates a WebSocketHost object for each WebSocket channel, and dispatches
+// WebSocketMsg_* messages sent from renderer to the appropriate WebSocketHost.
+class CONTENT_EXPORT WebSocketDispatcherHost : public BrowserMessageFilter {
+ public:
+  typedef base::Callback<net::URLRequestContext*()> GetRequestContextCallback;
+
+  // Given a routing_id and delay, WebSocketHostFactory returns a new
+  // instance of WebSocketHost or its subclass.
+  typedef base::Callback<WebSocketHost*(int, base::TimeDelta)>
+      WebSocketHostFactory;
+
+  // Return value for methods that may delete the WebSocketHost. This enum is
+  // binary-compatible with net::WebSocketEventInterface::ChannelState, to make
+  // conversion cheap. By using a separate enum including net/ header files can
+  // be avoided.
+  enum WebSocketHostState {
+    WEBSOCKET_HOST_ALIVE,
+    WEBSOCKET_HOST_DELETED
+  };
+
+  WebSocketDispatcherHost(int process_id,
+                          const GetRequestContextCallback& get_context_callback,
+                          ChromeBlobStorageContext* blob_storage_context,
+                          StoragePartition* storage_partition);
+
+  // BrowserMessageFilter:
+  bool OnMessageReceived(const IPC::Message& message) override;
+
+  // The following methods are used by WebSocketHost::EventInterface to send
+  // IPCs from the browser to the renderer or child process. Any of them may
+  // return WEBSOCKET_HOST_DELETED and delete the WebSocketHost on failure,
+  // leading to the WebSocketChannel and EventInterface also being deleted.
+
+  // Sends a WebSocketMsg_AddChannelResponse IPC.
+  WebSocketHostState SendAddChannelResponse(
+      int routing_id,
+      const std::string& selected_protocol,
+      const std::string& extensions) WARN_UNUSED_RESULT;
+
+  // Sends a WebSocketMsg_SendFrame IPC.
+  WebSocketHostState SendFrame(int routing_id,
+                               bool fin,
+                               WebSocketMessageType type,
+                               const std::vector<char>& data);
+
+  // Sends a WebSocketMsg_FlowControl IPC.
+  WebSocketHostState SendFlowControl(int routing_id,
+                                     int64_t quota) WARN_UNUSED_RESULT;
+
+  // Sends a WebSocketMsg_NotifyClosing IPC
+  WebSocketHostState NotifyClosingHandshake(int routing_id) WARN_UNUSED_RESULT;
+
+  // Sends a WebSocketMsg_NotifyStartOpeningHandshake IPC.
+  WebSocketHostState NotifyStartOpeningHandshake(
+      int routing_id,
+      const WebSocketHandshakeRequest& request) WARN_UNUSED_RESULT;
+
+  // Sends a WebSocketMsg_NotifyFinishOpeningHandshake IPC.
+  WebSocketHostState NotifyFinishOpeningHandshake(
+      int routing_id,
+      const WebSocketHandshakeResponse& response) WARN_UNUSED_RESULT;
+
+  // Sends a WebSocketMsg_NotifyFailure IPC and deletes and unregisters the
+  // channel.
+  WebSocketHostState NotifyFailure(
+      int routing_id,
+      const std::string& message) WARN_UNUSED_RESULT;
+
+  WebSocketHostState BlobSendComplete(int routing_id);
+
+  // Sends a WebSocketMsg_DropChannel IPC and deletes and unregisters the
+  // channel.
+  WebSocketHostState DoDropChannel(int routing_id,
+                                   bool was_clean,
+                                   uint16_t code,
+                                   const std::string& reason)
+      WARN_UNUSED_RESULT;
+
+  // Returns whether the associated renderer process can read raw cookies.
+  bool CanReadRawCookies() const;
+
+  int render_process_id() const { return process_id_; }
+
+  // Returns a BlobStorageContext associated with this object's render process.
+  // The pointer will be valid for as long this object is.
+  storage::BlobStorageContext* blob_storage_context() const;
+
+  // Returns the StoragePartition associated with this render process.
+  StoragePartition* storage_partition() const { return storage_partition_; }
+
+ protected:
+  // For testing. Specify a factory method that creates mock version of
+  // WebSocketHost.
+  WebSocketDispatcherHost(int process_id,
+                          const GetRequestContextCallback& get_context_callback,
+                          const WebSocketHostFactory& websocket_host_factory);
+
+  int num_pending_connections() const { return num_pending_connections_; }
+
+  // The number of handshakes that failed/succeeded in the current and
+  // previous time period, respectively.
+  int64_t num_failed_connections() const;
+  int64_t num_succeeded_connections() const;
+
+  ~WebSocketDispatcherHost() override;
+
+ private:
+  typedef base::hash_map<int, WebSocketHost*> WebSocketHostTable;
+
+  WebSocketHost* CreateWebSocketHost(int routing_id, base::TimeDelta delay);
+
+  // Looks up a WebSocketHost object by |routing_id|. Returns the object if one
+  // is found, or NULL otherwise.
+  WebSocketHost* GetHost(int routing_id) const;
+
+  // Sends the passed in IPC::Message via the BrowserMessageFilter::Send()
+  // method. If sending the IPC fails, assumes that this connection is no
+  // longer useable, calls DeleteWebSocketHost(), and returns
+  // WEBSOCKET_HOST_DELETED. The behaviour is the same for all message types.
+  WebSocketHostState SendOrDrop(IPC::Message* message) WARN_UNUSED_RESULT;
+
+  // Deletes the WebSocketHost object associated with the given |routing_id| and
+  // removes it from the |hosts_| table.
+  void DeleteWebSocketHost(int routing_id);
+
+  // Calculates the delay for per-renderer WebSocket throttling.
+  base::TimeDelta CalculateDelay() const;
+
+  // Rotates the counts of successful and failed connections for current
+  // and previous time periods. Called every two minutes while the counts
+  // are non-zero.
+  void ThrottlingPeriodTimerCallback();
+
+  // Table of WebSocketHost objects, owned by this object, indexed by
+  // routing_id.
+  WebSocketHostTable hosts_;
+
+  // The the process ID of the associated renderer process.
+  const int process_id_;
+
+  // A callback which returns the appropriate net::URLRequestContext for us to
+  // use.
+  GetRequestContextCallback get_context_callback_;
+
+  WebSocketHostFactory websocket_host_factory_;
+
+  // Timer and counters for per-renderer WebSocket throttling.
+  base::RepeatingTimer throttling_period_timer_;
+
+  // The current number of pending connections.
+  int num_pending_connections_;
+
+  // The number of handshakes that failed in the current and previous time
+  // period.
+  int64_t num_current_succeeded_connections_;
+  int64_t num_previous_succeeded_connections_;
+
+  // The number of handshakes that succeeded in the current and previous time
+  // period.
+  int64_t num_current_failed_connections_;
+  int64_t num_previous_failed_connections_;
+
+  // Needed to read from blobs for browser-side blob sending.
+  const scoped_refptr<const ChromeBlobStorageContext> blob_storage_context_;
+
+  // Needed to access to the StoragePartition for browser-side blob sending.
+  StoragePartition* const storage_partition_;
+
+  DISALLOW_COPY_AND_ASSIGN(WebSocketDispatcherHost);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_RENDERER_HOST_WEBSOCKET_DISPATCHER_HOST_H_