Skip to content

GitLab

T
tangled
Commit 6b4bf550 authored by vkuzkokov's avatar vkuzkokov Committed by Commit bot
Browse files
Options

DevTools: Merged AndroidWebSocket and AndroidWebSocketImpl 

This is done so that ADM::Device could have access to AndroidWebSocket's private members in order to close all sockets when device is released.

BUG=387067

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

Cr-Commit-Position: refs/heads/master@{#300663}
parent b7a7ed1a
Show whitespace changes
Inline Side-by-side
Showing with 147 additions and 213 deletions
chrome/browser/devtools/device/android_device_manager.h
View file @ 6b4bf550
......@@ -53,6 +53,7 @@ class AndroidDeviceManager
};
typedef base::Callback<void(const DeviceInfo&)> DeviceInfoCallback;
class Device;
class AndroidWebSocket {
public:
......@@ -66,9 +67,28 @@ class AndroidDeviceManager
virtual ~Delegate() {}
};
virtual ~AndroidWebSocket() {}
~AndroidWebSocket();
virtual void SendFrame(const std::string& message) = 0;
void SendFrame(const std::string& message);
private:
friend class Device;
class WebSocketImpl;
AndroidWebSocket(
scoped_refptr<Device> device,
const std::string& socket_name,
const std::string& url,
AndroidWebSocket::Delegate* delegate);
void Connected(int result, scoped_ptr<net::StreamSocket> socket);
void OnFrameRead(const std::string& message);
void OnSocketClosed();
scoped_refptr<Device> device_;
WebSocketImpl* socket_impl_;
Delegate* delegate_;
base::WeakPtrFactory<AndroidWebSocket> weak_factory_;
DISALLOW_COPY_AND_ASSIGN(AndroidWebSocket);
};
class DeviceProvider;
......@@ -76,10 +96,6 @@ class AndroidDeviceManager
class Device : public base::RefCountedThreadSafe<Device>,
public base::NonThreadSafe {
public:
typedef AndroidDeviceManager::DeviceInfoCallback DeviceInfoCallback;
typedef AndroidDeviceManager::CommandCallback CommandCallback;
typedef AndroidDeviceManager::SocketCallback SocketCallback;
void QueryDeviceInfo(const DeviceInfoCallback& callback);
void OpenSocket(const std::string& socket_name,
......@@ -92,7 +108,6 @@ class AndroidDeviceManager
void HttpUpgrade(const std::string& socket_name,
const std::string& url,
const SocketCallback& callback);
AndroidWebSocket* CreateWebSocket(
const std::string& socket_name,
const std::string& url,
......@@ -101,12 +116,14 @@ class AndroidDeviceManager
std::string serial() { return serial_; }
private:
friend class base::RefCountedThreadSafe<Device>;
friend class AndroidDeviceManager;
friend class AndroidWebSocket;
Device(scoped_refptr<base::MessageLoopProxy> device_message_loop,
scoped_refptr<DeviceProvider> provider,
const std::string& serial);
friend class base::RefCountedThreadSafe<Device>;
virtual ~Device();
scoped_refptr<base::MessageLoopProxy> device_message_loop_;
......
chrome/browser/devtools/device/android_web_socket.cc
View file @ 6b4bf550
......@@ -19,124 +19,27 @@ namespace {
const int kBufferSize = 16 * 1024;
class WebSocketImpl {
public:
typedef AndroidDeviceManager::AndroidWebSocket::Delegate Delegate;
WebSocketImpl(Delegate* delegate,
scoped_ptr<net::StreamSocket> socket);
void StartListening();
void SendFrame(const std::string& message);
private:
void OnBytesRead(scoped_refptr<net::IOBuffer> response_buffer, int result);
void SendPendingRequests(int result);
void Disconnect();
Delegate* delegate_;
scoped_ptr<net::StreamSocket> socket_;
std::string response_buffer_;
std::string request_buffer_;
base::ThreadChecker thread_checker_;
DISALLOW_COPY_AND_ASSIGN(WebSocketImpl);
};
} // namespace
class DelegateWrapper
: public AndroidDeviceManager::AndroidWebSocket::Delegate {
class AndroidDeviceManager::AndroidWebSocket::WebSocketImpl {
public:
DelegateWrapper(base::WeakPtr<Delegate> weak_delegate,
scoped_refptr<base::MessageLoopProxy> message_loop)
: weak_delegate_(weak_delegate),
message_loop_(message_loop) {
}
~DelegateWrapper() override {}
// AndroidWebSocket::Delegate implementation
void OnSocketOpened() override {
message_loop_->PostTask(FROM_HERE,
base::Bind(&Delegate::OnSocketOpened, weak_delegate_));
}
void OnFrameRead(const std::string& message) override {
message_loop_->PostTask(FROM_HERE,
base::Bind(&Delegate::OnFrameRead, weak_delegate_, message));
WebSocketImpl(scoped_refptr<base::MessageLoopProxy> response_message_loop,
base::WeakPtr<AndroidWebSocket> weak_socket,
scoped_ptr<net::StreamSocket> socket)
: response_message_loop_(response_message_loop),
weak_socket_(weak_socket),
socket_(socket.Pass()) {
thread_checker_.DetachFromThread();
}
void OnSocketClosed() override {
message_loop_->PostTask(FROM_HERE,
base::Bind(&Delegate::OnSocketClosed, weak_delegate_));
void StartListening() {
DCHECK(thread_checker_.CalledOnValidThread());
DCHECK(socket_);
scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kBufferSize));
Read(buffer);
}
private:
base::WeakPtr<Delegate> weak_delegate_;
scoped_refptr<base::MessageLoopProxy> message_loop_;
};
class AndroidWebSocketImpl
: public AndroidDeviceManager::AndroidWebSocket,
public AndroidDeviceManager::AndroidWebSocket::Delegate {
public:
typedef AndroidDeviceManager::Device Device;
AndroidWebSocketImpl(
scoped_refptr<base::MessageLoopProxy> device_message_loop,
scoped_refptr<Device> device,
const std::string& socket_name,
const std::string& url,
AndroidWebSocket::Delegate* delegate);
~AndroidWebSocketImpl() override;
// AndroidWebSocket implementation
void SendFrame(const std::string& message) override;
// AndroidWebSocket::Delegate implementation
void OnSocketOpened() override;
void OnFrameRead(const std::string& message) override;
void OnSocketClosed() override;
private:
void Connected(int result, scoped_ptr<net::StreamSocket> socket);
scoped_refptr<base::MessageLoopProxy> device_message_loop_;
scoped_refptr<Device> device_;
std::string socket_name_;
std::string url_;
WebSocketImpl* connection_;
DelegateWrapper* delegate_wrapper_;
AndroidWebSocket::Delegate* delegate_;
base::WeakPtrFactory<AndroidWebSocketImpl> weak_factory_;
DISALLOW_COPY_AND_ASSIGN(AndroidWebSocketImpl);
};
AndroidWebSocketImpl::AndroidWebSocketImpl(
scoped_refptr<base::MessageLoopProxy> device_message_loop,
scoped_refptr<Device> device,
const std::string& socket_name,
const std::string& url,
AndroidWebSocket::Delegate* delegate)
: device_message_loop_(device_message_loop),
device_(device),
socket_name_(socket_name),
url_(url),
delegate_(delegate),
weak_factory_(this) {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
DCHECK(delegate_);
device_->HttpUpgrade(
socket_name_, url_,
base::Bind(&AndroidWebSocketImpl::Connected, weak_factory_.GetWeakPtr()));
}
void AndroidWebSocketImpl::SendFrame(const std::string& message) {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
device_message_loop_->PostTask(
FROM_HERE,
base::Bind(&WebSocketImpl::SendFrame,
base::Unretained(connection_), message));
}
void WebSocketImpl::SendFrame(const std::string& message) {
void SendFrame(const std::string& message) {
DCHECK(thread_checker_.CalledOnValidThread());
if (!socket_)
return;
......@@ -145,43 +48,10 @@ void WebSocketImpl::SendFrame(const std::string& message) {
request_buffer_ += encoded_frame;
if (request_buffer_.length() == encoded_frame.length())
SendPendingRequests(0);
}
AndroidWebSocketImpl::~AndroidWebSocketImpl() {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
device_message_loop_->DeleteSoon(FROM_HERE, connection_);
device_message_loop_->DeleteSoon(FROM_HERE, delegate_wrapper_);
}
WebSocketImpl::WebSocketImpl(Delegate* delegate,
scoped_ptr<net::StreamSocket> socket)
: delegate_(delegate),
socket_(socket.Pass()) {
thread_checker_.DetachFromThread();
}
void AndroidWebSocketImpl::Connected(int result,
scoped_ptr<net::StreamSocket> socket) {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
if (result != net::OK || socket == NULL) {
OnSocketClosed();
return;
}
delegate_wrapper_ = new DelegateWrapper(weak_factory_.GetWeakPtr(),
base::MessageLoopProxy::current());
connection_ = new WebSocketImpl(delegate_wrapper_, socket.Pass());
device_message_loop_->PostTask(
FROM_HERE,
base::Bind(&WebSocketImpl::StartListening,
base::Unretained(connection_)));
OnSocketOpened();
}
void WebSocketImpl::StartListening() {
DCHECK(thread_checker_.CalledOnValidThread());
DCHECK(socket_);
scoped_refptr<net::IOBuffer> response_buffer =
new net::IOBuffer(kBufferSize);
private:
void Read(scoped_refptr<net::IOBuffer> response_buffer) {
int result = socket_->Read(
response_buffer.get(),
kBufferSize,
......@@ -189,16 +59,14 @@ void WebSocketImpl::StartListening() {
base::Unretained(this), response_buffer));
if (result != net::ERR_IO_PENDING)
OnBytesRead(response_buffer, result);
}
}
void WebSocketImpl::OnBytesRead(scoped_refptr<net::IOBuffer> response_buffer,
int result) {
void OnBytesRead(scoped_refptr<net::IOBuffer> response_buffer, int result) {
DCHECK(thread_checker_.CalledOnValidThread());
if (result <= 0) {
Disconnect();
return;
}
response_buffer_.append(response_buffer->data(), result);
int bytes_consumed;
......@@ -208,7 +76,9 @@ void WebSocketImpl::OnBytesRead(scoped_refptr<net::IOBuffer> response_buffer,
while (parse_result == WebSocket::FRAME_OK) {
response_buffer_ = response_buffer_.substr(bytes_consumed);
delegate_->OnFrameRead(output);
response_message_loop_->PostTask(
FROM_HERE,
base::Bind(&AndroidWebSocket::OnFrameRead, weak_socket_, output));
parse_result = WebSocket::DecodeFrameHybi17(
response_buffer_, false, &bytes_consumed, &output);
}
......@@ -218,17 +88,10 @@ void WebSocketImpl::OnBytesRead(scoped_refptr<net::IOBuffer> response_buffer,
Disconnect();
return;
}
Read(response_buffer);
}
result = socket_->Read(
response_buffer.get(),
kBufferSize,
base::Bind(&WebSocketImpl::OnBytesRead,
base::Unretained(this), response_buffer));
if (result != net::ERR_IO_PENDING)
OnBytesRead(response_buffer, result);
}
void WebSocketImpl::SendPendingRequests(int result) {
void SendPendingRequests(int result) {
DCHECK(thread_checker_.CalledOnValidThread());
if (result < 0) {
Disconnect();
......@@ -245,36 +108,90 @@ void WebSocketImpl::SendPendingRequests(int result) {
base::Unretained(this)));
if (result != net::ERR_IO_PENDING)
SendPendingRequests(result);
}
}
void WebSocketImpl::Disconnect() {
void Disconnect() {
DCHECK(thread_checker_.CalledOnValidThread());
socket_.reset();
delegate_->OnSocketClosed();
response_message_loop_->PostTask(
FROM_HERE,
base::Bind(&AndroidWebSocket::OnSocketClosed, weak_socket_));
}
scoped_refptr<base::MessageLoopProxy> response_message_loop_;
base::WeakPtr<AndroidWebSocket> weak_socket_;
scoped_ptr<net::StreamSocket> socket_;
std::string response_buffer_;
std::string request_buffer_;
base::ThreadChecker thread_checker_;
DISALLOW_COPY_AND_ASSIGN(WebSocketImpl);
};
AndroidDeviceManager::AndroidWebSocket::AndroidWebSocket(
scoped_refptr<Device> device,
const std::string& socket_name,
const std::string& url,
Delegate* delegate)
: device_(device),
socket_impl_(nullptr),
delegate_(delegate),
weak_factory_(this) {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
DCHECK(delegate_);
device_->HttpUpgrade(
socket_name, url,
base::Bind(&AndroidWebSocket::Connected, weak_factory_.GetWeakPtr()));
}
AndroidDeviceManager::AndroidWebSocket::~AndroidWebSocket() {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
if (socket_impl_)
device_->device_message_loop_->DeleteSoon(FROM_HERE, socket_impl_);
}
void AndroidDeviceManager::AndroidWebSocket::SendFrame(
const std::string& message) {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
DCHECK(socket_impl_);
device_->device_message_loop_->PostTask(
FROM_HERE,
base::Bind(&WebSocketImpl::SendFrame,
base::Unretained(socket_impl_), message));
}
void AndroidWebSocketImpl::OnSocketOpened() {
void AndroidDeviceManager::AndroidWebSocket::Connected(
int result,
scoped_ptr<net::StreamSocket> socket) {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
if (result != net::OK || !socket.get()) {
OnSocketClosed();
return;
}
socket_impl_ = new WebSocketImpl(base::MessageLoopProxy::current(),
weak_factory_.GetWeakPtr(),
socket.Pass());
device_->device_message_loop_->PostTask(
FROM_HERE,
base::Bind(&WebSocketImpl::StartListening,
base::Unretained(socket_impl_)));
delegate_->OnSocketOpened();
}
void AndroidWebSocketImpl::OnFrameRead(const std::string& message) {
void AndroidDeviceManager::AndroidWebSocket::OnFrameRead(
const std::string& message) {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
delegate_->OnFrameRead(message);
}
void AndroidWebSocketImpl::OnSocketClosed() {
void AndroidDeviceManager::AndroidWebSocket::OnSocketClosed() {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
delegate_->OnSocketClosed();
}
} // namespace
AndroidDeviceManager::AndroidWebSocket*
AndroidDeviceManager::Device::CreateWebSocket(
const std::string& socket,
const std::string& url,
AndroidDeviceManager::AndroidWebSocket::Delegate* delegate) {
return new AndroidWebSocketImpl(
device_message_loop_, this, socket, url, delegate);
AndroidWebSocket::Delegate* delegate) {
return new AndroidWebSocket(this, socket, url, delegate);
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment