0

Remove old WebSocket implementation from content/

Remove the old SocketStream-based WebSocket implementation from
content/.

Large parts of the implementation still exist in net/. They will be
removed in a subsequent CL.

There are also a few traces in chrome/, and some interfaces in Blink
that cannot be removed until this CL is submitted.

BUG=423201
TEST=layout tests, browser_tests

Review URL: https://codereview.chromium.org/655253006

Cr-Commit-Position: refs/heads/master@{#301075}
This commit is contained in:
ricea
2014-10-24 01:53:55 -07:00
committed by Commit bot
parent 821aa6e20b
commit 8e60ab5d14
31 changed files with 1 additions and 1375 deletions

@ -92,7 +92,6 @@
#include "content/browser/renderer_host/render_view_host_impl.h"
#include "content/browser/renderer_host/render_widget_helper.h"
#include "content/browser/renderer_host/render_widget_host_impl.h"
#include "content/browser/renderer_host/socket_stream_dispatcher_host.h"
#include "content/browser/renderer_host/text_input_client_message_filter.h"
#include "content/browser/renderer_host/websocket_dispatcher_host.h"
#include "content/browser/resolve_proxy_msg_helper.h"
@ -799,16 +798,6 @@ void RenderProcessHostImpl::CreateMessageFilters() {
AddFilter(browser_cdm_manager_.get());
#endif
SocketStreamDispatcherHost::GetRequestContextCallback
request_context_callback(
base::Bind(&GetRequestContext, request_context,
media_request_context));
SocketStreamDispatcherHost* socket_stream_dispatcher_host =
new SocketStreamDispatcherHost(
GetID(), request_context_callback, resource_context);
AddFilter(socket_stream_dispatcher_host);
WebSocketDispatcherHost::GetRequestContextCallback
websocket_request_context_callback(
base::Bind(&GetRequestContext, request_context,

@ -1,278 +0,0 @@
// 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.
#include "content/browser/renderer_host/socket_stream_dispatcher_host.h"
#include <string>
#include "base/logging.h"
#include "content/browser/renderer_host/socket_stream_host.h"
#include "content/browser/ssl/ssl_manager.h"
#include "content/common/resource_messages.h"
#include "content/common/socket_stream.h"
#include "content/common/socket_stream_messages.h"
#include "content/public/browser/content_browser_client.h"
#include "net/base/net_errors.h"
#include "net/cookies/canonical_cookie.h"
#include "net/url_request/url_request_context_getter.h"
#include "net/websockets/websocket_job.h"
#include "net/websockets/websocket_throttle.h"
namespace content {
namespace {
const size_t kMaxSocketStreamHosts = 16 * 1024;
} // namespace
SocketStreamDispatcherHost::SocketStreamDispatcherHost(
int render_process_id,
const GetRequestContextCallback& request_context_callback,
ResourceContext* resource_context)
: BrowserMessageFilter(SocketStreamMsgStart),
render_process_id_(render_process_id),
request_context_callback_(request_context_callback),
resource_context_(resource_context),
on_shutdown_(false) {
net::WebSocketJob::EnsureInit();
}
bool SocketStreamDispatcherHost::OnMessageReceived(
const IPC::Message& message) {
if (on_shutdown_)
return false;
bool handled = true;
IPC_BEGIN_MESSAGE_MAP(SocketStreamDispatcherHost, message)
IPC_MESSAGE_HANDLER(SocketStreamHostMsg_Connect, OnConnect)
IPC_MESSAGE_HANDLER(SocketStreamHostMsg_SendData, OnSendData)
IPC_MESSAGE_HANDLER(SocketStreamHostMsg_Close, OnCloseReq)
IPC_MESSAGE_UNHANDLED(handled = false)
IPC_END_MESSAGE_MAP()
return handled;
}
// SocketStream::Delegate methods implementations.
void SocketStreamDispatcherHost::OnConnected(net::SocketStream* socket,
int max_pending_send_allowed) {
int socket_id = SocketStreamHost::SocketIdFromSocketStream(socket);
DVLOG(2) << "SocketStreamDispatcherHost::OnConnected socket_id=" << socket_id
<< " max_pending_send_allowed=" << max_pending_send_allowed;
if (socket_id == kNoSocketId) {
DVLOG(1) << "NoSocketId in OnConnected";
return;
}
if (!Send(new SocketStreamMsg_Connected(
socket_id, max_pending_send_allowed))) {
DVLOG(1) << "SocketStreamMsg_Connected failed.";
DeleteSocketStreamHost(socket_id);
}
}
void SocketStreamDispatcherHost::OnSentData(net::SocketStream* socket,
int amount_sent) {
int socket_id = SocketStreamHost::SocketIdFromSocketStream(socket);
DVLOG(2) << "SocketStreamDispatcherHost::OnSentData socket_id=" << socket_id
<< " amount_sent=" << amount_sent;
if (socket_id == kNoSocketId) {
DVLOG(1) << "NoSocketId in OnSentData";
return;
}
if (!Send(new SocketStreamMsg_SentData(socket_id, amount_sent))) {
DVLOG(1) << "SocketStreamMsg_SentData failed.";
DeleteSocketStreamHost(socket_id);
}
}
void SocketStreamDispatcherHost::OnReceivedData(
net::SocketStream* socket, const char* data, int len) {
int socket_id = SocketStreamHost::SocketIdFromSocketStream(socket);
DVLOG(2) << "SocketStreamDispatcherHost::OnReceiveData socket_id="
<< socket_id;
if (socket_id == kNoSocketId) {
DVLOG(1) << "NoSocketId in OnReceivedData";
return;
}
if (!Send(new SocketStreamMsg_ReceivedData(
socket_id, std::vector<char>(data, data + len)))) {
DVLOG(1) << "SocketStreamMsg_ReceivedData failed.";
DeleteSocketStreamHost(socket_id);
}
}
void SocketStreamDispatcherHost::OnClose(net::SocketStream* socket) {
int socket_id = SocketStreamHost::SocketIdFromSocketStream(socket);
DVLOG(2) << "SocketStreamDispatcherHost::OnClosed socket_id=" << socket_id;
if (socket_id == kNoSocketId) {
DVLOG(1) << "NoSocketId in OnClose";
return;
}
DeleteSocketStreamHost(socket_id);
}
void SocketStreamDispatcherHost::OnError(const net::SocketStream* socket,
int error) {
int socket_id = SocketStreamHost::SocketIdFromSocketStream(socket);
DVLOG(2) << "SocketStreamDispatcherHost::OnError socket_id=" << socket_id;
if (socket_id == content::kNoSocketId) {
DVLOG(1) << "NoSocketId in OnError";
return;
}
// SocketStream::Delegate::OnError() events are handled as WebSocket error
// event when user agent was required to fail WebSocket connection or the
// WebSocket connection is closed with prejudice.
if (!Send(new SocketStreamMsg_Failed(socket_id, error))) {
DVLOG(1) << "SocketStreamMsg_Failed failed.";
DeleteSocketStreamHost(socket_id);
}
}
void SocketStreamDispatcherHost::OnSSLCertificateError(
net::SocketStream* socket, const net::SSLInfo& ssl_info, bool fatal) {
int socket_id = SocketStreamHost::SocketIdFromSocketStream(socket);
DVLOG(2) << "SocketStreamDispatcherHost::OnSSLCertificateError socket_id="
<< socket_id;
if (socket_id == kNoSocketId) {
DVLOG(1) << "NoSocketId in OnSSLCertificateError";
return;
}
SocketStreamHost* socket_stream_host = hosts_.Lookup(socket_id);
DCHECK(socket_stream_host);
SSLManager::OnSSLCertificateError(
socket_stream_host->AsSSLErrorHandlerDelegate(),
RESOURCE_TYPE_SUB_RESOURCE,
socket->url(), render_process_id_, socket_stream_host->render_frame_id(),
ssl_info, fatal);
}
bool SocketStreamDispatcherHost::CanGetCookies(net::SocketStream* socket,
const GURL& url) {
int socket_id = SocketStreamHost::SocketIdFromSocketStream(socket);
if (socket_id == kNoSocketId) {
return false;
}
SocketStreamHost* socket_stream_host = hosts_.Lookup(socket_id);
DCHECK(socket_stream_host);
return GetContentClient()->browser()->AllowGetCookie(
url,
url,
net::CookieList(),
resource_context_,
render_process_id_,
socket_stream_host->render_frame_id());
}
bool SocketStreamDispatcherHost::CanSetCookie(net::SocketStream* request,
const GURL& url,
const std::string& cookie_line,
net::CookieOptions* options) {
int socket_id = SocketStreamHost::SocketIdFromSocketStream(request);
if (socket_id == kNoSocketId) {
return false;
}
SocketStreamHost* socket_stream_host = hosts_.Lookup(socket_id);
DCHECK(socket_stream_host);
return GetContentClient()->browser()->AllowSetCookie(
url,
url,
cookie_line,
resource_context_,
render_process_id_,
socket_stream_host->render_frame_id(),
options);
}
SocketStreamDispatcherHost::~SocketStreamDispatcherHost() {
DCHECK_CURRENTLY_ON(BrowserThread::IO);
Shutdown();
}
// Message handlers called by OnMessageReceived.
void SocketStreamDispatcherHost::OnConnect(int render_frame_id,
const GURL& url,
int socket_id) {
DVLOG(2) << "SocketStreamDispatcherHost::OnConnect"
<< " render_frame_id=" << render_frame_id
<< " url=" << url
<< " socket_id=" << socket_id;
DCHECK_NE(kNoSocketId, socket_id);
if (hosts_.size() >= kMaxSocketStreamHosts) {
if (!Send(new SocketStreamMsg_Failed(socket_id,
net::ERR_TOO_MANY_SOCKET_STREAMS))) {
DVLOG(1) << "SocketStreamMsg_Failed failed.";
}
if (!Send(new SocketStreamMsg_Closed(socket_id))) {
DVLOG(1) << "SocketStreamMsg_Closed failed.";
}
return;
}
if (hosts_.Lookup(socket_id)) {
DVLOG(1) << "socket_id=" << socket_id << " already registered.";
return;
}
// Note that the SocketStreamHost is responsible for checking that |url|
// is valid.
SocketStreamHost* socket_stream_host =
new SocketStreamHost(this, render_process_id_, render_frame_id,
socket_id);
hosts_.AddWithID(socket_stream_host, socket_id);
socket_stream_host->Connect(url, GetURLRequestContext());
DVLOG(2) << "SocketStreamDispatcherHost::OnConnect -> " << socket_id;
}
void SocketStreamDispatcherHost::OnSendData(
int socket_id, const std::vector<char>& data) {
DVLOG(2) << "SocketStreamDispatcherHost::OnSendData socket_id=" << socket_id;
SocketStreamHost* socket_stream_host = hosts_.Lookup(socket_id);
if (!socket_stream_host) {
DVLOG(1) << "socket_id=" << socket_id << " already closed.";
return;
}
if (!socket_stream_host->SendData(data)) {
// Cannot accept more data to send.
socket_stream_host->Close();
}
}
void SocketStreamDispatcherHost::OnCloseReq(int socket_id) {
DVLOG(2) << "SocketStreamDispatcherHost::OnCloseReq socket_id=" << socket_id;
SocketStreamHost* socket_stream_host = hosts_.Lookup(socket_id);
if (!socket_stream_host)
return;
socket_stream_host->Close();
}
void SocketStreamDispatcherHost::DeleteSocketStreamHost(int socket_id) {
SocketStreamHost* socket_stream_host = hosts_.Lookup(socket_id);
DCHECK(socket_stream_host);
delete socket_stream_host;
hosts_.Remove(socket_id);
if (!Send(new SocketStreamMsg_Closed(socket_id))) {
DVLOG(1) << "SocketStreamMsg_Closed failed.";
}
}
net::URLRequestContext* SocketStreamDispatcherHost::GetURLRequestContext() {
return request_context_callback_.Run(RESOURCE_TYPE_SUB_RESOURCE);
}
void SocketStreamDispatcherHost::Shutdown() {
DCHECK_CURRENTLY_ON(BrowserThread::IO);
// TODO(ukai): Implement IDMap::RemoveAll().
for (IDMap<SocketStreamHost>::const_iterator iter(&hosts_);
!iter.IsAtEnd();
iter.Advance()) {
int socket_id = iter.GetCurrentKey();
const SocketStreamHost* socket_stream_host = iter.GetCurrentValue();
delete socket_stream_host;
hosts_.Remove(socket_id);
}
on_shutdown_ = true;
}
} // namespace content

@ -1,89 +0,0 @@
// 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_BROWSER_RENDERER_HOST_SOCKET_STREAM_DISPATCHER_HOST_H_
#define CONTENT_BROWSER_RENDERER_HOST_SOCKET_STREAM_DISPATCHER_HOST_H_
#include <vector>
#include "base/callback_forward.h"
#include "base/id_map.h"
#include "content/public/browser/browser_message_filter.h"
#include "content/public/common/resource_type.h"
#include "net/socket_stream/socket_stream.h"
class GURL;
namespace net {
class SSLInfo;
}
namespace content {
class ResourceContext;
class SocketStreamHost;
// Dispatches ViewHostMsg_SocketStream_* messages sent from renderer.
// It also acts as SocketStream::Delegate so that it sends
// ViewMsg_SocketStream_* messages back to renderer.
class SocketStreamDispatcherHost : public BrowserMessageFilter,
public net::SocketStream::Delegate {
public:
typedef base::Callback<net::URLRequestContext*(ResourceType)>
GetRequestContextCallback;
SocketStreamDispatcherHost(
int render_process_id,
const GetRequestContextCallback& request_context_callback,
ResourceContext* resource_context);
// BrowserMessageFilter:
bool OnMessageReceived(const IPC::Message& message) override;
// Make this object inactive.
// Remove all active SocketStreamHost objects.
void Shutdown();
// SocketStream::Delegate:
void OnConnected(net::SocketStream* socket,
int max_pending_send_allowed) override;
void OnSentData(net::SocketStream* socket, int amount_sent) override;
void OnReceivedData(net::SocketStream* socket,
const char* data,
int len) override;
void OnClose(net::SocketStream* socket) override;
void OnError(const net::SocketStream* socket, int error) override;
void OnSSLCertificateError(net::SocketStream* socket,
const net::SSLInfo& ssl_info,
bool fatal) override;
bool CanGetCookies(net::SocketStream* socket, const GURL& url) override;
bool CanSetCookie(net::SocketStream* request,
const GURL& url,
const std::string& cookie_line,
net::CookieOptions* options) override;
protected:
~SocketStreamDispatcherHost() override;
private:
// Message handlers called by OnMessageReceived.
void OnConnect(int render_frame_id, const GURL& url, int socket_id);
void OnSendData(int socket_id, const std::vector<char>& data);
void OnCloseReq(int socket_id);
void DeleteSocketStreamHost(int socket_id);
net::URLRequestContext* GetURLRequestContext();
IDMap<SocketStreamHost> hosts_;
int render_process_id_;
GetRequestContextCallback request_context_callback_;
ResourceContext* resource_context_;
bool on_shutdown_;
DISALLOW_COPY_AND_ASSIGN(SocketStreamDispatcherHost);
};
} // namespace content
#endif // CONTENT_BROWSER_RENDERER_HOST_SOCKET_STREAM_DISPATCHER_HOST_H_

@ -1,110 +0,0 @@
// 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.
#include "content/browser/renderer_host/socket_stream_host.h"
#include "base/logging.h"
#include "content/common/socket_stream.h"
#include "content/public/browser/content_browser_client.h"
#include "net/socket_stream/socket_stream_job.h"
#include "net/url_request/url_request_context.h"
namespace content {
namespace {
const char* kSocketIdKey = "socketId";
class SocketStreamId : public net::SocketStream::UserData {
public:
explicit SocketStreamId(int socket_id) : socket_id_(socket_id) {}
~SocketStreamId() override {}
int socket_id() const { return socket_id_; }
private:
int socket_id_;
};
} // namespace
SocketStreamHost::SocketStreamHost(
net::SocketStream::Delegate* delegate,
int child_id,
int render_frame_id,
int socket_id)
: delegate_(delegate),
child_id_(child_id),
render_frame_id_(render_frame_id),
socket_id_(socket_id),
weak_ptr_factory_(this) {
DCHECK_NE(socket_id_, kNoSocketId);
VLOG(1) << "SocketStreamHost: render_frame_id=" << render_frame_id
<< " socket_id=" << socket_id_;
}
/* static */
int SocketStreamHost::SocketIdFromSocketStream(
const net::SocketStream* socket) {
net::SocketStream::UserData* d = socket->GetUserData(kSocketIdKey);
if (d) {
SocketStreamId* socket_stream_id = static_cast<SocketStreamId*>(d);
return socket_stream_id->socket_id();
}
return kNoSocketId;
}
SocketStreamHost::~SocketStreamHost() {
VLOG(1) << "SocketStreamHost destructed socket_id=" << socket_id_;
job_->DetachContext();
job_->DetachDelegate();
}
void SocketStreamHost::Connect(const GURL& url,
net::URLRequestContext* request_context) {
VLOG(1) << "SocketStreamHost::Connect url=" << url;
job_ = net::SocketStreamJob::CreateSocketStreamJob(
url, delegate_, request_context->transport_security_state(),
request_context->ssl_config_service(),
request_context,
GetContentClient()->browser()->OverrideCookieStoreForRenderProcess(
child_id_));
job_->SetUserData(kSocketIdKey, new SocketStreamId(socket_id_));
job_->Connect();
}
bool SocketStreamHost::SendData(const std::vector<char>& data) {
VLOG(1) << "SocketStreamHost::SendData";
return job_.get() && job_->SendData(&data[0], data.size());
}
void SocketStreamHost::Close() {
VLOG(1) << "SocketStreamHost::Close";
if (!job_.get())
return;
job_->Close();
}
base::WeakPtr<SSLErrorHandler::Delegate>
SocketStreamHost::AsSSLErrorHandlerDelegate() {
return weak_ptr_factory_.GetWeakPtr();
}
void SocketStreamHost::CancelSSLRequest(int error,
const net::SSLInfo* ssl_info) {
VLOG(1) << "SocketStreamHost::CancelSSLRequest socket_id=" << socket_id_;
if (!job_.get())
return;
if (ssl_info)
job_->CancelWithSSLError(*ssl_info);
else
job_->CancelWithError(error);
}
void SocketStreamHost::ContinueSSLRequest() {
VLOG(1) << "SocketStreamHost::ContinueSSLRequest socket_id=" << socket_id_;
if (!job_.get())
return;
job_->ContinueDespiteError();
}
} // namespace content

@ -1,79 +0,0 @@
// 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_BROWSER_RENDERER_HOST_SOCKET_STREAM_HOST_H_
#define CONTENT_BROWSER_RENDERER_HOST_SOCKET_STREAM_HOST_H_
#include <vector>
#include "base/memory/ref_counted.h"
#include "base/memory/weak_ptr.h"
#include "content/browser/ssl/ssl_error_handler.h"
#include "net/socket_stream/socket_stream.h"
class GURL;
namespace net {
class SocketStreamJob;
class URLRequestContext;
class SSLInfo;
} // namespace net
namespace content {
// Host of SocketStreamHandle. Each SocketStreamHandle will have an unique
// socket_id assigned by SocketStreamHost constructor. If socket id is
// kNoSocketId, there is no SocketStreamHost. Each SocketStreamHost has
// SocketStream to manage bi-directional communication over socket stream. The
// lifetime of an instance of this class is completely controlled by the
// SocketStreamDispatcherHost.
class SocketStreamHost : public SSLErrorHandler::Delegate {
public:
SocketStreamHost(net::SocketStream::Delegate* delegate,
int child_id,
int render_frame_id,
int socket_id);
~SocketStreamHost() override;
// Gets socket_id associated with |socket|.
static int SocketIdFromSocketStream(const net::SocketStream* socket);
int render_frame_id() const { return render_frame_id_; }
int socket_id() const { return socket_id_; }
// Starts to open connection to |url|.
void Connect(const GURL& url, net::URLRequestContext* request_context);
// Sends |data| over the socket stream.
// socket stream must be open to send data.
// Returns true if the data is put in transmit buffer in socket stream.
// Returns false otherwise (transmit buffer exceeds limit, or socket
// stream is closed).
bool SendData(const std::vector<char>& data);
// Closes the socket stream.
void Close();
base::WeakPtr<SSLErrorHandler::Delegate> AsSSLErrorHandlerDelegate();
// SSLErrorHandler::Delegate methods:
void CancelSSLRequest(int error, const net::SSLInfo* ssl_info) override;
void ContinueSSLRequest() override;
private:
net::SocketStream::Delegate* delegate_;
int child_id_;
int render_frame_id_;
int socket_id_;
scoped_refptr<net::SocketStreamJob> job_;
base::WeakPtrFactory<SocketStreamHost> weak_ptr_factory_;
DISALLOW_COPY_AND_ASSIGN(SocketStreamHost);
};
} // namespace content
#endif // CONTENT_BROWSER_RENDERER_HOST_SOCKET_STREAM_HOST_H_

@ -35,7 +35,6 @@
#include "content/child/geofencing/web_geofencing_provider_impl.h"
#include "content/child/web_discardable_memory_impl.h"
#include "content/child/web_gesture_curve_impl.h"
#include "content/child/web_socket_stream_handle_impl.h"
#include "content/child/web_url_loader_impl.h"
#include "content/child/websocket_bridge.h"
#include "content/child/webthread_impl.h"
@ -62,7 +61,6 @@ using blink::WebData;
using blink::WebFallbackThemeEngine;
using blink::WebLocalizedString;
using blink::WebString;
using blink::WebSocketStreamHandle;
using blink::WebThemeEngine;
using blink::WebURL;
using blink::WebURLError;
@ -441,10 +439,6 @@ WebURLLoader* BlinkPlatformImpl::createURLLoader() {
child_thread ? child_thread->resource_dispatcher() : NULL);
}
WebSocketStreamHandle* BlinkPlatformImpl::createSocketStreamHandle() {
return new WebSocketStreamHandleImpl;
}
blink::WebSocketHandle* BlinkPlatformImpl::createWebSocketHandle() {
return new WebSocketBridge;
}

@ -75,7 +75,6 @@ class CONTENT_EXPORT BlinkPlatformImpl
size_t bytes);
virtual size_t maxDecodedImageBytes() override;
virtual blink::WebURLLoader* createURLLoader();
virtual blink::WebSocketStreamHandle* createSocketStreamHandle();
virtual blink::WebSocketHandle* createWebSocketHandle() override;
virtual blink::WebString userAgent();
virtual blink::WebData parseDataURL(

@ -40,7 +40,6 @@
#include "content/child/quota_message_filter.h"
#include "content/child/resource_dispatcher.h"
#include "content/child/service_worker/service_worker_message_filter.h"
#include "content/child/socket_stream_dispatcher.h"
#include "content/child/thread_safe_sender.h"
#include "content/child/websocket_dispatcher.h"
#include "content/common/child_process_messages.h"
@ -274,7 +273,6 @@ void ChildThread::Init(const Options& options) {
base::MessageLoopProxy::current().get(), sync_message_filter_.get());
resource_dispatcher_.reset(new ResourceDispatcher(this));
socket_stream_dispatcher_.reset(new SocketStreamDispatcher());
websocket_dispatcher_.reset(new WebSocketDispatcher);
file_system_dispatcher_.reset(new FileSystemDispatcher());
@ -464,8 +462,6 @@ bool ChildThread::OnMessageReceived(const IPC::Message& msg) {
// Resource responses are sent to the resource dispatcher.
if (resource_dispatcher_->OnMessageReceived(msg))
return true;
if (socket_stream_dispatcher_->OnMessageReceived(msg))
return true;
if (websocket_dispatcher_->OnMessageReceived(msg))
return true;
if (file_system_dispatcher_->OnMessageReceived(msg))

@ -46,7 +46,6 @@ class ServiceWorkerMessageFilter;
class QuotaDispatcher;
class QuotaMessageFilter;
class ResourceDispatcher;
class SocketStreamDispatcher;
class ThreadSafeSender;
class WebSocketDispatcher;
struct RequestInfo;
@ -106,10 +105,6 @@ class CONTENT_EXPORT ChildThread : public IPC::Listener, public IPC::Sender {
return resource_dispatcher_.get();
}
SocketStreamDispatcher* socket_stream_dispatcher() const {
return socket_stream_dispatcher_.get();
}
WebSocketDispatcher* websocket_dispatcher() const {
return websocket_dispatcher_.get();
}
@ -222,9 +217,6 @@ class CONTENT_EXPORT ChildThread : public IPC::Listener, public IPC::Sender {
// Handles resource loads for this process.
scoped_ptr<ResourceDispatcher> resource_dispatcher_;
// Handles SocketStream for this process.
scoped_ptr<SocketStreamDispatcher> socket_stream_dispatcher_;
scoped_ptr<WebSocketDispatcher> websocket_dispatcher_;
// The OnChannelError() callback was invoked - the channel is dead, don't

@ -1,255 +0,0 @@
// 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.
#include "content/child/socket_stream_dispatcher.h"
#include <string>
#include <vector>
#include "base/bind.h"
#include "base/id_map.h"
#include "base/lazy_instance.h"
#include "base/memory/ref_counted.h"
#include "base/message_loop/message_loop.h"
#include "base/strings/string16.h"
#include "base/strings/utf_string_conversions.h"
#include "content/child/child_thread.h"
#include "content/child/web_socket_stream_handle_bridge.h"
#include "content/child/web_socket_stream_handle_delegate.h"
#include "content/child/web_socket_stream_handle_impl.h"
#include "content/common/socket_stream.h"
#include "content/common/socket_stream_handle_data.h"
#include "content/common/socket_stream_messages.h"
#include "net/base/net_errors.h"
#include "url/gurl.h"
namespace content {
// IPCWebSocketStreamHandleBridge is owned by each SocketStreamHandle.
// It communicates with the main browser process via SocketStreamDispatcher.
class IPCWebSocketStreamHandleBridge : public WebSocketStreamHandleBridge {
public:
IPCWebSocketStreamHandleBridge(blink::WebSocketStreamHandle* handle,
WebSocketStreamHandleDelegate* delegate)
: socket_id_(kNoSocketId), handle_(handle), delegate_(delegate) {}
// Returns the handle having given id or NULL if there is no such handle.
static IPCWebSocketStreamHandleBridge* FromSocketId(int id);
// WebSocketStreamHandleBridge methods.
void Connect(const GURL& url) override;
bool Send(const std::vector<char>& data) override;
void Close() override;
// Called by SocketStreamDispatcher.
void OnConnected(int max_amount_send_allowed);
void OnSentData(int amount_sent);
void OnReceivedData(const std::vector<char>& data);
void OnClosed();
void OnFailed(int error_code, const std::string& error_msg);
private:
~IPCWebSocketStreamHandleBridge() override;
// The ID for this bridge and corresponding SocketStream instance in the
// browser process.
int socket_id_;
blink::WebSocketStreamHandle* handle_;
WebSocketStreamHandleDelegate* delegate_;
// Map from ID to bridge instance.
static base::LazyInstance<IDMap<IPCWebSocketStreamHandleBridge> >::Leaky
all_bridges;
};
// static
base::LazyInstance<IDMap<IPCWebSocketStreamHandleBridge> >::Leaky
IPCWebSocketStreamHandleBridge::all_bridges = LAZY_INSTANCE_INITIALIZER;
/* static */
IPCWebSocketStreamHandleBridge* IPCWebSocketStreamHandleBridge::FromSocketId(
int id) {
return all_bridges.Get().Lookup(id);
}
IPCWebSocketStreamHandleBridge::~IPCWebSocketStreamHandleBridge() {
DVLOG(1) << "Bridge (" << this << ", socket_id_=" << socket_id_
<< ") Destructor";
if (socket_id_ == kNoSocketId)
return;
ChildThread::current()->Send(new SocketStreamHostMsg_Close(socket_id_));
socket_id_ = kNoSocketId;
}
void IPCWebSocketStreamHandleBridge::Connect(const GURL& url) {
DVLOG(1) << "Bridge (" << this << ") Connect (url=" << url << ")";
DCHECK_EQ(socket_id_, kNoSocketId);
if (delegate_)
delegate_->WillOpenStream(handle_, url);
socket_id_ = all_bridges.Get().Add(this);
DCHECK_NE(socket_id_, kNoSocketId);
int render_frame_id = MSG_ROUTING_NONE;
WebSocketStreamHandleImpl* impl =
static_cast<WebSocketStreamHandleImpl*>(handle_);
const SocketStreamHandleData* data =
static_cast<SocketStreamHandleData*>(impl->GetUserData(handle_));
if (data)
render_frame_id = data->render_frame_id();
AddRef(); // Released in OnClosed().
ChildThread::current()->Send(
new SocketStreamHostMsg_Connect(render_frame_id, url, socket_id_));
DVLOG(1) << "Bridge #" << socket_id_ << " sent IPC Connect";
// TODO(ukai): timeout to OnConnected.
}
bool IPCWebSocketStreamHandleBridge::Send(const std::vector<char>& data) {
DVLOG(1) << "Bridge #" << socket_id_ << " Send (" << data.size()
<< " bytes)";
ChildThread::current()->Send(
new SocketStreamHostMsg_SendData(socket_id_, data));
if (delegate_)
delegate_->WillSendData(handle_, &data[0], data.size());
return true;
}
void IPCWebSocketStreamHandleBridge::Close() {
DVLOG(1) << "Bridge #" << socket_id_ << " Close";
ChildThread::current()->Send(new SocketStreamHostMsg_Close(socket_id_));
}
void IPCWebSocketStreamHandleBridge::OnConnected(int max_pending_send_allowed) {
DVLOG(1) << "Bridge #" << socket_id_
<< " OnConnected (max_pending_send_allowed="
<< max_pending_send_allowed << ")";
if (delegate_)
delegate_->DidOpenStream(handle_, max_pending_send_allowed);
}
void IPCWebSocketStreamHandleBridge::OnSentData(int amount_sent) {
DVLOG(1) << "Bridge #" << socket_id_ << " OnSentData (" << amount_sent
<< " bytes)";
if (delegate_)
delegate_->DidSendData(handle_, amount_sent);
}
void IPCWebSocketStreamHandleBridge::OnReceivedData(
const std::vector<char>& data) {
DVLOG(1) << "Bridge #" << socket_id_ << " OnReceiveData (" << data.size()
<< " bytes)";
if (delegate_)
delegate_->DidReceiveData(handle_, &data[0], data.size());
}
void IPCWebSocketStreamHandleBridge::OnClosed() {
DVLOG(1) << "Bridge #" << socket_id_ << " OnClosed";
if (socket_id_ != kNoSocketId) {
all_bridges.Get().Remove(socket_id_);
socket_id_ = kNoSocketId;
}
if (delegate_)
delegate_->DidClose(handle_);
delegate_ = NULL;
Release();
}
void IPCWebSocketStreamHandleBridge::OnFailed(int error_code,
const std::string& error_msg) {
DVLOG(1) << "Bridge #" << socket_id_ << " OnFailed (error_code=" << error_code
<< ")";
if (delegate_)
delegate_->DidFail(handle_, error_code, base::ASCIIToUTF16(error_msg));
}
SocketStreamDispatcher::SocketStreamDispatcher() {
}
// static
WebSocketStreamHandleBridge* SocketStreamDispatcher::CreateBridge(
blink::WebSocketStreamHandle* handle,
WebSocketStreamHandleDelegate* delegate) {
return new IPCWebSocketStreamHandleBridge(handle, delegate);
}
bool SocketStreamDispatcher::OnMessageReceived(const IPC::Message& msg) {
bool handled = true;
IPC_BEGIN_MESSAGE_MAP(SocketStreamDispatcher, msg)
IPC_MESSAGE_HANDLER(SocketStreamMsg_Connected, OnConnected)
IPC_MESSAGE_HANDLER(SocketStreamMsg_SentData, OnSentData)
IPC_MESSAGE_HANDLER(SocketStreamMsg_ReceivedData, OnReceivedData)
IPC_MESSAGE_HANDLER(SocketStreamMsg_Closed, OnClosed)
IPC_MESSAGE_HANDLER(SocketStreamMsg_Failed, OnFailed)
IPC_MESSAGE_UNHANDLED(handled = false)
IPC_END_MESSAGE_MAP()
return handled;
}
void SocketStreamDispatcher::OnConnected(int socket_id,
int max_pending_send_allowed) {
DVLOG(1) << "SocketStreamDispatcher::OnConnected (max_pending_send_allowed="
<< max_pending_send_allowed << ") to socket_id=" << socket_id;
IPCWebSocketStreamHandleBridge* bridge =
IPCWebSocketStreamHandleBridge::FromSocketId(socket_id);
if (bridge)
bridge->OnConnected(max_pending_send_allowed);
else
DLOG(ERROR) << "No bridge for socket_id=" << socket_id;
}
void SocketStreamDispatcher::OnSentData(int socket_id, int amount_sent) {
DVLOG(1) << "SocketStreamDispatcher::OnSentData (" << amount_sent
<< " bytes) to socket_id=" << socket_id;
IPCWebSocketStreamHandleBridge* bridge =
IPCWebSocketStreamHandleBridge::FromSocketId(socket_id);
if (bridge)
bridge->OnSentData(amount_sent);
else
DLOG(ERROR) << "No bridge for socket_id=" << socket_id;
}
void SocketStreamDispatcher::OnReceivedData(
int socket_id, const std::vector<char>& data) {
DVLOG(1) << "SocketStreamDispatcher::OnReceivedData (" << data.size()
<< " bytes) to socket_id=" << socket_id;
IPCWebSocketStreamHandleBridge* bridge =
IPCWebSocketStreamHandleBridge::FromSocketId(socket_id);
if (bridge)
bridge->OnReceivedData(data);
else
DLOG(ERROR) << "No bridge for socket_id=" << socket_id;
}
void SocketStreamDispatcher::OnClosed(int socket_id) {
DVLOG(1) << "SocketStreamDispatcher::OnClosed to socket_id=" << socket_id;
IPCWebSocketStreamHandleBridge* bridge =
IPCWebSocketStreamHandleBridge::FromSocketId(socket_id);
if (bridge)
bridge->OnClosed();
else
DLOG(ERROR) << "No bridge for socket_id=" << socket_id;
}
void SocketStreamDispatcher::OnFailed(int socket_id, int error_code) {
IPCWebSocketStreamHandleBridge* bridge =
IPCWebSocketStreamHandleBridge::FromSocketId(socket_id);
if (bridge)
bridge->OnFailed(error_code, net::ErrorToString(error_code));
else
DLOG(ERROR) << "No bridge for socket_id=" << socket_id;
}
} // namespace content

@ -1,51 +0,0 @@
// 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_CHILD_SOCKET_STREAM_DISPATCHER_H_
#define CONTENT_CHILD_SOCKET_STREAM_DISPATCHER_H_
#include <vector>
#include "base/basictypes.h"
#include "base/compiler_specific.h"
#include "ipc/ipc_listener.h"
namespace blink {
class WebSocketStreamHandle;
}
namespace content {
class WebSocketStreamHandleBridge;
class WebSocketStreamHandleDelegate;
// Dispatches socket stream related messages sent to a child process from the
// main browser process. There is one instance per child process. Messages
// are dispatched on the main child thread. The RenderThread class
// creates an instance of SocketStreamDispatcher and delegates calls to it.
class SocketStreamDispatcher : public IPC::Listener {
public:
SocketStreamDispatcher();
~SocketStreamDispatcher() override {}
static WebSocketStreamHandleBridge* CreateBridge(
blink::WebSocketStreamHandle* handle,
WebSocketStreamHandleDelegate* delegate);
// IPC::Listener implementation.
bool OnMessageReceived(const IPC::Message& msg) override;
private:
void OnConnected(int socket_id, int max_amount_send_allowed);
void OnSentData(int socket_id, int amount_sent);
void OnReceivedData(int socket_id, const std::vector<char>& data);
void OnClosed(int socket_id);
void OnFailed(int socket_id, int error_code);
DISALLOW_COPY_AND_ASSIGN(SocketStreamDispatcher);
};
} // namespace content
#endif // CONTENT_CHILD_SOCKET_STREAM_DISPATCHER_H_

@ -1,37 +0,0 @@
// Copyright 2014 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_CHILD_WEB_SOCKET_STREAM_HANDLE_BRIDGE_H_
#define CONTENT_CHILD_WEB_SOCKET_STREAM_HANDLE_BRIDGE_H_
#include <vector>
#include "base/basictypes.h"
#include "base/memory/ref_counted.h"
class GURL;
namespace content {
class WebSocketStreamHandleBridge
: public base::RefCountedThreadSafe<WebSocketStreamHandleBridge> {
public:
virtual void Connect(const GURL& url) = 0;
virtual bool Send(const std::vector<char>& data) = 0;
virtual void Close() = 0;
protected:
friend class base::RefCountedThreadSafe<WebSocketStreamHandleBridge>;
WebSocketStreamHandleBridge() {}
virtual ~WebSocketStreamHandleBridge() {}
private:
DISALLOW_COPY_AND_ASSIGN(WebSocketStreamHandleBridge);
};
} // namespace content
#endif // CONTENT_CHILD_WEB_SOCKET_STREAM_HANDLE_BRIDGE_H_

@ -1,44 +0,0 @@
// Copyright 2014 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_CHILD_WEB_SOCKET_STREAM_HANDLE_DELEGATE_H_
#define CONTENT_CHILD_WEB_SOCKET_STREAM_HANDLE_DELEGATE_H_
#include "base/strings/string16.h"
class GURL;
namespace blink {
class WebSocketStreamHandle;
}
namespace content {
class WebSocketStreamHandleDelegate {
public:
WebSocketStreamHandleDelegate() {}
virtual void WillOpenStream(blink::WebSocketStreamHandle* handle,
const GURL& url) {}
virtual void WillSendData(blink::WebSocketStreamHandle* handle,
const char* data, int len) {}
virtual void DidOpenStream(blink::WebSocketStreamHandle* handle,
int max_amount_send_allowed) {}
virtual void DidSendData(blink::WebSocketStreamHandle* handle,
int amount_sent) {}
virtual void DidReceiveData(blink::WebSocketStreamHandle* handle,
const char* data, int len) {}
virtual void DidClose(blink::WebSocketStreamHandle*) {}
virtual void DidFail(blink::WebSocketStreamHandle* handle,
int error_code,
const base::string16& error_msg) {}
protected:
virtual ~WebSocketStreamHandleDelegate() {}
};
} // namespace content
#endif // CONTENT_CHILD_WEB_SOCKET_STREAM_HANDLE_DELEGATE_H_

@ -1,194 +0,0 @@
// Copyright 2014 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.
// An implementation of WebSocketStreamHandle.
#include "content/child/web_socket_stream_handle_impl.h"
#include <vector>
#include "base/compiler_specific.h"
#include "base/logging.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "base/strings/string16.h"
#include "content/child/child_thread.h"
#include "content/child/socket_stream_dispatcher.h"
#include "content/child/web_socket_stream_handle_bridge.h"
#include "content/child/web_socket_stream_handle_delegate.h"
#include "third_party/WebKit/public/platform/WebData.h"
#include "third_party/WebKit/public/platform/WebSocketStreamError.h"
#include "third_party/WebKit/public/platform/WebSocketStreamHandleClient.h"
#include "third_party/WebKit/public/platform/WebURL.h"
using blink::WebData;
using blink::WebSocketStreamError;
using blink::WebSocketStreamHandle;
using blink::WebSocketStreamHandleClient;
using blink::WebURL;
namespace content {
// WebSocketStreamHandleImpl::Context -----------------------------------------
class WebSocketStreamHandleImpl::Context
: public base::RefCounted<Context>,
public WebSocketStreamHandleDelegate {
public:
explicit Context(WebSocketStreamHandleImpl* handle);
WebSocketStreamHandleClient* client() const { return client_; }
void set_client(WebSocketStreamHandleClient* client) {
client_ = client;
}
void Connect(const WebURL& url);
bool Send(const WebData& data);
void Close();
// Must be called before |handle_| or |client_| is deleted.
// Once detached, it never calls |client_| back.
void Detach();
// WebSocketStreamHandleDelegate methods:
void DidOpenStream(WebSocketStreamHandle*, int) override;
void DidSendData(WebSocketStreamHandle*, int) override;
void DidReceiveData(WebSocketStreamHandle*, const char*, int) override;
void DidClose(WebSocketStreamHandle*) override;
void DidFail(WebSocketStreamHandle*, int, const base::string16&) override;
private:
friend class base::RefCounted<Context>;
~Context() override {
DCHECK(!handle_);
DCHECK(!client_);
DCHECK(!bridge_.get());
}
WebSocketStreamHandleImpl* handle_;
WebSocketStreamHandleClient* client_;
// |bridge_| is alive from Connect to DidClose, so Context must be alive
// in the time period.
scoped_refptr<WebSocketStreamHandleBridge> bridge_;
DISALLOW_COPY_AND_ASSIGN(Context);
};
WebSocketStreamHandleImpl::Context::Context(WebSocketStreamHandleImpl* handle)
: handle_(handle),
client_(NULL) {
}
void WebSocketStreamHandleImpl::Context::Connect(const WebURL& url) {
VLOG(1) << "Connect url=" << url;
DCHECK(!bridge_.get());
SocketStreamDispatcher* dispatcher =
ChildThread::current()->socket_stream_dispatcher();
bridge_ = dispatcher->CreateBridge(handle_, this);
AddRef(); // Will be released by DidClose().
bridge_->Connect(url);
}
bool WebSocketStreamHandleImpl::Context::Send(const WebData& data) {
VLOG(1) << "Send data.size=" << data.size();
DCHECK(bridge_.get());
return bridge_->Send(
std::vector<char>(data.data(), data.data() + data.size()));
}
void WebSocketStreamHandleImpl::Context::Close() {
VLOG(1) << "Close";
if (bridge_.get())
bridge_->Close();
}
void WebSocketStreamHandleImpl::Context::Detach() {
handle_ = NULL;
client_ = NULL;
// If Connect was called, |bridge_| is not NULL, so that this Context closes
// the |bridge_| here. Then |bridge_| will call back DidClose, and will
// be released by itself.
// Otherwise, |bridge_| is NULL.
if (bridge_.get())
bridge_->Close();
}
void WebSocketStreamHandleImpl::Context::DidOpenStream(
WebSocketStreamHandle* web_handle, int max_amount_send_allowed) {
VLOG(1) << "DidOpen";
if (client_)
client_->didOpenStream(handle_, max_amount_send_allowed);
}
void WebSocketStreamHandleImpl::Context::DidSendData(
WebSocketStreamHandle* web_handle, int amount_sent) {
if (client_)
client_->didSendData(handle_, amount_sent);
}
void WebSocketStreamHandleImpl::Context::DidReceiveData(
WebSocketStreamHandle* web_handle, const char* data, int size) {
if (client_)
client_->didReceiveData(handle_, WebData(data, size));
}
void WebSocketStreamHandleImpl::Context::DidClose(
WebSocketStreamHandle* web_handle) {
VLOG(1) << "DidClose";
bridge_ = NULL;
WebSocketStreamHandleImpl* handle = handle_;
handle_ = NULL;
if (client_) {
WebSocketStreamHandleClient* client = client_;
client_ = NULL;
client->didClose(handle);
}
Release();
}
void WebSocketStreamHandleImpl::Context::DidFail(
WebSocketStreamHandle* web_handle,
int error_code,
const base::string16& error_msg) {
VLOG(1) << "DidFail";
if (client_) {
client_->didFail(
handle_,
WebSocketStreamError(error_code, error_msg));
}
}
// WebSocketStreamHandleImpl ------------------------------------------------
WebSocketStreamHandleImpl::WebSocketStreamHandleImpl()
: context_(new Context(this)) {
}
WebSocketStreamHandleImpl::~WebSocketStreamHandleImpl() {
// We won't receive any events from |context_|.
// |context_| is ref counted, and will be released when it received
// DidClose.
context_->Detach();
}
void WebSocketStreamHandleImpl::connect(
const WebURL& url, WebSocketStreamHandleClient* client) {
VLOG(1) << "connect url=" << url;
DCHECK(!context_->client());
context_->set_client(client);
context_->Connect(url);
}
bool WebSocketStreamHandleImpl::send(const WebData& data) {
return context_->Send(data);
}
void WebSocketStreamHandleImpl::close() {
context_->Close();
}
} // namespace content

@ -1,35 +0,0 @@
// Copyright 2014 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_CHILD_WEB_SOCKET_STREAM_HANDLE_IMPL_H_
#define CONTENT_CHILD_WEB_SOCKET_STREAM_HANDLE_IMPL_H_
#include "base/memory/ref_counted.h"
#include "base/supports_user_data.h"
#include "third_party/WebKit/public/platform/WebSocketStreamHandle.h"
namespace content {
class WebSocketStreamHandleImpl : public base::SupportsUserData,
public blink::WebSocketStreamHandle {
public:
WebSocketStreamHandleImpl();
virtual ~WebSocketStreamHandleImpl();
// WebSocketStreamHandle methods:
virtual void connect(const blink::WebURL& url,
blink::WebSocketStreamHandleClient* client);
virtual bool send(const blink::WebData& data);
virtual void close();
private:
class Context;
scoped_refptr<Context> context_;
DISALLOW_COPY_AND_ASSIGN(WebSocketStreamHandleImpl);
};
} // namespace content
#endif // CONTENT_CHILD_WEB_SOCKET_STREAM_HANDLE_IMPL_H_

@ -57,7 +57,6 @@
#include "content/common/screen_orientation_messages.h"
#include "content/common/service_worker/embedded_worker_messages.h"
#include "content/common/service_worker/service_worker_messages.h"
#include "content/common/socket_stream_messages.h"
#include "content/common/speech_recognition_messages.h"
#include "content/common/text_input_client_messages.h"
#include "content/common/utility_messages.h"

@ -1,14 +0,0 @@
// 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_COMMON_SOCKET_STREAM_H_
#define CONTENT_COMMON_SOCKET_STREAM_H_
namespace content {
const int kNoSocketId = 0;
} // namespace content
#endif // CONTENT_COMMON_SOCKET_STREAM_H_

@ -1,30 +0,0 @@
// 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_RENDERER_SOCKET_STREAM_HANDLE_DATA_H_
#define CONTENT_RENDERER_SOCKET_STREAM_HANDLE_DATA_H_
#include "base/supports_user_data.h"
#include "content/common/content_export.h"
namespace content {
// User data stored in each WebSocketStreamHandleImpl.
class SocketStreamHandleData : public base::SupportsUserData::Data {
public:
explicit SocketStreamHandleData(int render_frame_id)
: render_frame_id_(render_frame_id) {}
~SocketStreamHandleData() override {}
int render_frame_id() const { return render_frame_id_; }
private:
int render_frame_id_;
DISALLOW_COPY_AND_ASSIGN(SocketStreamHandleData);
};
} // namespace content
#endif // CONTENT_RENDERER_SOCKET_STREAM_HANDLE_DATA_H_

@ -1,80 +0,0 @@
// 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.
// Multiply-included message file, hence no include guard.
#include <vector>
#include "content/common/content_export.h"
#include "ipc/ipc_message_macros.h"
#include "ipc/ipc_param_traits.h"
#include "url/gurl.h"
#undef IPC_MESSAGE_EXPORT
#define IPC_MESSAGE_EXPORT CONTENT_EXPORT
#define IPC_MESSAGE_START SocketStreamMsgStart
// Web Sockets messages sent from the renderer to the browser.
// Open new Socket Stream for the |socket_url| identified by |socket_id|
// in the renderer process.
// The browser starts connecting asynchronously.
// Once Socket Stream connection is established, the browser will send
// SocketStreamMsg_Connected back.
// |render_frame_id| must be the routing id of RenderFrameImpl to which the
// Socket Stream belongs.
IPC_MESSAGE_CONTROL3(SocketStreamHostMsg_Connect,
int /* render_frame_id */,
GURL /* socket_url */,
int /* socket_id */)
// Request to send data on the Socket Stream.
// SocketStreamHandle can send data at most |max_pending_send_allowed| bytes,
// which is given by ViewMsg_SocketStream_Connected at any time.
// The number of pending bytes can be tracked by size of |data| sent
// and |amount_sent| parameter of ViewMsg_SocketStream_DataSent.
// That is, the following constraints is applied:
// (accumulated total of |data|) - (accumulated total of |amount_sent|)
// <= |max_pending_send_allowed|
// If the SocketStreamHandle ever tries to exceed the
// |max_pending_send_allowed|, the connection will be closed.
IPC_MESSAGE_CONTROL2(SocketStreamHostMsg_SendData,
int /* socket_id */,
std::vector<char> /* data */)
// Request to close the Socket Stream.
// The browser will send ViewMsg_SocketStream_Closed back when the Socket
// Stream is completely closed.
IPC_MESSAGE_CONTROL1(SocketStreamHostMsg_Close,
int /* socket_id */)
// Speech input messages sent from the browser to the renderer.
// A |socket_id| is assigned by SocketStreamHostMsg_Connect.
// The Socket Stream is connected. The SocketStreamHandle should keep track
// of how much it has pending (how much it has requested to be sent) and
// shouldn't go over |max_pending_send_allowed| bytes.
IPC_MESSAGE_CONTROL2(SocketStreamMsg_Connected,
int /* socket_id */,
int /* max_pending_send_allowed */)
// |data| is received on the Socket Stream.
IPC_MESSAGE_CONTROL2(SocketStreamMsg_ReceivedData,
int /* socket_id */,
std::vector<char> /* data */)
// |amount_sent| bytes of data requested by
// SocketStreamHostMsg_SendData has been sent on the Socket Stream.
IPC_MESSAGE_CONTROL2(SocketStreamMsg_SentData,
int /* socket_id */,
int /* amount_sent */)
// The Socket Stream is closed.
IPC_MESSAGE_CONTROL1(SocketStreamMsg_Closed,
int /* socket_id */)
// The Socket Stream is failed.
IPC_MESSAGE_CONTROL2(SocketStreamMsg_Failed,
int /* socket_id */,
int /* error_code */)

@ -5,10 +5,7 @@
// Multiply-included message file, hence no include guard.
// This file defines the IPCs for the browser-side implementation of
// WebSockets. For the legacy renderer-side implementation, see
// socket_stream_messages.h.
// TODO(ricea): Fix this comment when the legacy implementation has been
// removed.
// WebSockets.
//
// This IPC interface is based on the WebSocket multiplexing draft spec,
// http://tools.ietf.org/html/draft-ietf-hybi-websocket-multiplexing-09

@ -1124,10 +1124,6 @@
'browser/renderer_host/sandbox_ipc_linux.h',
'browser/renderer_host/software_frame_manager.cc',
'browser/renderer_host/software_frame_manager.h',
'browser/renderer_host/socket_stream_dispatcher_host.cc',
'browser/renderer_host/socket_stream_dispatcher_host.h',
'browser/renderer_host/socket_stream_host.cc',
'browser/renderer_host/socket_stream_host.h',
'browser/renderer_host/text_input_client_mac.h',
'browser/renderer_host/text_input_client_mac.mm',
'browser/renderer_host/text_input_client_message_filter.h',

@ -185,8 +185,6 @@
'child/simple_webmimeregistry_impl.h',
'child/site_isolation_policy.cc',
'child/site_isolation_policy.h',
'child/socket_stream_dispatcher.cc',
'child/socket_stream_dispatcher.h',
'child/sync_load_response.cc',
'child/sync_load_response.h',
'child/thread_safe_sender.cc',
@ -199,10 +197,6 @@
'child/web_discardable_memory_impl.h',
'child/web_gesture_curve_impl.cc',
'child/web_gesture_curve_impl.h',
'child/web_socket_stream_handle_bridge.h',
'child/web_socket_stream_handle_delegate.h',
'child/web_socket_stream_handle_impl.cc',
'child/web_socket_stream_handle_impl.h',
'child/web_url_loader_impl.cc',
'child/web_url_loader_impl.h',
'child/web_url_request_util.cc',

@ -484,9 +484,6 @@
'common/set_process_title.h',
'common/set_process_title_linux.cc',
'common/set_process_title_linux.h',
'common/socket_stream.h',
'common/socket_stream_handle_data.h',
'common/socket_stream_messages.h',
'common/speech_recognition_messages.h',
'common/ssl_status_serialization.cc',
'common/ssl_status_serialization.h',

@ -220,12 +220,6 @@ blink::WebURLLoader* PpapiBlinkPlatformImpl::createURLLoader() {
return NULL;
}
blink::WebSocketStreamHandle*
PpapiBlinkPlatformImpl::createSocketStreamHandle() {
NOTREACHED();
return NULL;
}
void PpapiBlinkPlatformImpl::getPluginList(
bool refresh,
blink::WebPluginListBuilder* builder) {

@ -39,7 +39,6 @@ class PpapiBlinkPlatformImpl : public BlinkPlatformImpl {
virtual blink::WebString defaultLocale();
virtual blink::WebThemeEngine* themeEngine();
virtual blink::WebURLLoader* createURLLoader();
virtual blink::WebSocketStreamHandle* createSocketStreamHandle();
virtual void getPluginList(bool refresh, blink::WebPluginListBuilder*);
virtual blink::WebData loadResource(const char* name);
virtual blink::WebStorageNamespace* createLocalStorageNamespace();

@ -26,7 +26,6 @@
#include "content/child/service_worker/service_worker_network_provider.h"
#include "content/child/service_worker/service_worker_provider_context.h"
#include "content/child/service_worker/web_service_worker_provider_impl.h"
#include "content/child/web_socket_stream_handle_impl.h"
#include "content/child/web_url_loader_impl.h"
#include "content/child/web_url_request_util.h"
#include "content/child/webmessageportchannel_impl.h"
@ -36,7 +35,6 @@
#include "content/common/frame_messages.h"
#include "content/common/input_messages.h"
#include "content/common/service_worker/service_worker_types.h"
#include "content/common/socket_stream_handle_data.h"
#include "content/common/swapped_out_messages.h"
#include "content/common/view_messages.h"
#include "content/public/common/bindings_policy.h"
@ -3104,13 +3102,6 @@ void RenderFrameImpl::requestStorageQuota(
QuotaDispatcher::CreateWebStorageQuotaCallbacksWrapper(callbacks));
}
void RenderFrameImpl::willOpenSocketStream(
blink::WebSocketStreamHandle* handle) {
WebSocketStreamHandleImpl* impl =
static_cast<WebSocketStreamHandleImpl*>(handle);
impl->SetUserData(handle, new SocketStreamHandleData(routing_id_));
}
void RenderFrameImpl::willOpenWebSocket(blink::WebSocketHandle* handle) {
WebSocketBridge* impl = static_cast<WebSocketBridge*>(handle);
impl->set_render_frame_id(routing_id_);

@ -437,8 +437,6 @@ class CONTENT_EXPORT RenderFrameImpl
blink::WebStorageQuotaType type,
unsigned long long requested_size,
blink::WebStorageQuotaCallbacks callbacks);
virtual void willOpenSocketStream(
blink::WebSocketStreamHandle* handle);
virtual void willOpenWebSocket(blink::WebSocketHandle* handle);
virtual blink::WebGeolocationClient* geolocationClient();
virtual blink::WebPushClient* pushClient();

@ -48,7 +48,6 @@
#include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
#include "content/common/input_messages.h"
#include "content/common/pepper_messages.h"
#include "content/common/socket_stream_handle_data.h"
#include "content/common/ssl_status_serialization.h"
#include "content/common/view_messages.h"
#include "content/public/common/bindings_policy.h"
@ -129,7 +128,6 @@
#include "third_party/WebKit/public/platform/WebPoint.h"
#include "third_party/WebKit/public/platform/WebRect.h"
#include "third_party/WebKit/public/platform/WebSize.h"
#include "third_party/WebKit/public/platform/WebSocketStreamHandle.h"
#include "third_party/WebKit/public/platform/WebStorageQuotaCallbacks.h"
#include "third_party/WebKit/public/platform/WebString.h"
#include "third_party/WebKit/public/platform/WebURL.h"
@ -280,7 +278,6 @@ using blink::WebSecurityPolicy;
using blink::WebSerializedScriptValue;
using blink::WebSettings;
using blink::WebSize;
using blink::WebSocketStreamHandle;
using blink::WebStorageNamespace;
using blink::WebStorageQuotaCallbacks;
using blink::WebStorageQuotaError;

@ -99,7 +99,6 @@ class WebPeerConnection00HandlerClient;
class WebMouseEvent;
class WebPeerConnectionHandler;
class WebPeerConnectionHandlerClient;
class WebSocketStreamHandle;
class WebSpeechRecognizer;
class WebStorageNamespace;
class WebTouchEvent;

@ -114,10 +114,4 @@ bool ShellNetworkDelegate::OnCanThrottleRequest(
return false;
}
int ShellNetworkDelegate::OnBeforeSocketStreamConnect(
net::SocketStream* socket,
const net::CompletionCallback& callback) {
return net::OK;
}
} // namespace content

@ -54,9 +54,6 @@ class ShellNetworkDelegate : public net::NetworkDelegate {
bool OnCanAccessFile(const net::URLRequest& request,
const base::FilePath& path) const override;
bool OnCanThrottleRequest(const net::URLRequest& request) const override;
int OnBeforeSocketStreamConnect(
net::SocketStream* stream,
const net::CompletionCallback& callback) override;
DISALLOW_COPY_AND_ASSIGN(ShellNetworkDelegate);
};