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:
content
browser
renderer_host
child
blink_platform_impl.ccblink_platform_impl.hchild_thread.ccchild_thread.hsocket_stream_dispatcher.ccsocket_stream_dispatcher.hweb_socket_stream_handle_bridge.hweb_socket_stream_handle_delegate.hweb_socket_stream_handle_impl.ccweb_socket_stream_handle_impl.h
common
content_message_generator.hsocket_stream.hsocket_stream_handle_data.hsocket_stream_messages.hwebsocket_messages.h
content_browser.gypicontent_child.gypicontent_common.gypippapi_plugin
renderer
shell
@ -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);
|
||||
};
|
||||
|
Reference in New Issue
Block a user