Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(54)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: chrome/browser/devtools/device/android_web_socket.cc

Issue 620183002: DevTools: Merged AndroidWebSocket and AndroidWebSocketImpl (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@page
Patch Set: Created 6 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « chrome/browser/devtools/device/android_device_manager.h ('k') | no next file » | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: chrome/browser/devtools/device/android_web_socket.cc
diff --git a/chrome/browser/devtools/device/android_web_socket.cc b/chrome/browser/devtools/device/android_web_socket.cc
index 2a3886b309450689faafbf70d2790e67b09353b2..f0e6812cd3d197e030b3f51eea0214fce36ecc48 100644
--- a/chrome/browser/devtools/device/android_web_socket.cc
+++ b/chrome/browser/devtools/device/android_web_socket.cc
@@ -19,262 +19,176 @@ 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) {
- }
-
- virtual ~DelegateWrapper() {}
-
- // AndroidWebSocket::Delegate implementation
- virtual void OnSocketOpened() OVERRIDE {
- message_loop_->PostTask(FROM_HERE,
- base::Bind(&Delegate::OnSocketOpened, weak_delegate_));
+ 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();
}
- virtual void OnFrameRead(const std::string& message) OVERRIDE {
- message_loop_->PostTask(FROM_HERE,
- base::Bind(&Delegate::OnFrameRead, weak_delegate_, message));
+ void StartListening() {
+ DCHECK(thread_checker_.CalledOnValidThread());
+ DCHECK(socket_);
+ Read(new net::IOBuffer(kBufferSize));
}
- virtual void OnSocketClosed() OVERRIDE {
- message_loop_->PostTask(FROM_HERE,
- base::Bind(&Delegate::OnSocketClosed, weak_delegate_));
+ void SendFrame(const std::string& message) {
+ DCHECK(thread_checker_.CalledOnValidThread());
+ if (!socket_)
+ return;
+ int mask = base::RandInt(0, 0x7FFFFFFF);
+ std::string encoded_frame = WebSocket::EncodeFrameHybi17(message, mask);
+ request_buffer_ += encoded_frame;
+ if (request_buffer_.length() == encoded_frame.length())
+ SendPendingRequests(0);
}
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);
+ void Read(scoped_refptr<net::IOBuffer> response_buffer) {
+ int 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);
+ }
- virtual ~AndroidWebSocketImpl();
+ 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;
+ std::string output;
+ WebSocket::ParseResult parse_result = WebSocket::DecodeFrameHybi17(
+ response_buffer_, false, &bytes_consumed, &output);
- // AndroidWebSocket implementation
- virtual void SendFrame(const std::string& message) OVERRIDE;
+ while (parse_result == WebSocket::FRAME_OK) {
+ response_buffer_ = response_buffer_.substr(bytes_consumed);
+ response_message_loop_->PostTask(
+ FROM_HERE,
+ base::Bind(&AndroidWebSocket::OnFrameRead, weak_socket_, output));
+ parse_result = WebSocket::DecodeFrameHybi17(
+ response_buffer_, false, &bytes_consumed, &output);
+ }
+
+ if (parse_result == WebSocket::FRAME_ERROR ||
+ parse_result == WebSocket::FRAME_CLOSE) {
+ Disconnect();
+ return;
+ }
+ Read(response_buffer);
+ }
- // AndroidWebSocket::Delegate implementation
- virtual void OnSocketOpened() OVERRIDE;
- virtual void OnFrameRead(const std::string& message) OVERRIDE;
- virtual void OnSocketClosed() OVERRIDE;
+ void SendPendingRequests(int result) {
+ DCHECK(thread_checker_.CalledOnValidThread());
+ if (result < 0) {
+ Disconnect();
+ return;
+ }
+ request_buffer_ = request_buffer_.substr(result);
+ if (request_buffer_.empty())
+ return;
+
+ scoped_refptr<net::StringIOBuffer> buffer =
+ new net::StringIOBuffer(request_buffer_);
+ result = socket_->Write(buffer.get(), buffer->size(),
+ base::Bind(&WebSocketImpl::SendPendingRequests,
+ base::Unretained(this)));
+ if (result != net::ERR_IO_PENDING)
+ SendPendingRequests(result);
+ }
- private:
- void Connected(int result, scoped_ptr<net::StreamSocket> socket);
+ void Disconnect() {
+ DCHECK(thread_checker_.CalledOnValidThread());
+ socket_.reset();
+ response_message_loop_->PostTask(
+ FROM_HERE,
+ base::Bind(&AndroidWebSocket::OnSocketClosed, weak_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);
+ 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);
};
-AndroidWebSocketImpl::AndroidWebSocketImpl(
- scoped_refptr<base::MessageLoopProxy> device_message_loop,
+AndroidDeviceManager::AndroidWebSocket::AndroidWebSocket(
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),
+ Delegate* delegate)
+ : device_(device),
url_(url),
delegate_(delegate),
weak_factory_(this) {
dgozman 2014/10/03 19:25:17 socket_impl_(nullptr)
vkuzkokov 2014/10/06 14:31:43 Done.
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
DCHECK(delegate_);
device_->HttpUpgrade(
- socket_name_, url_,
- base::Bind(&AndroidWebSocketImpl::Connected, weak_factory_.GetWeakPtr()));
+ socket_name, url_,
+ base::Bind(&AndroidWebSocket::Connected, weak_factory_.GetWeakPtr()));
}
-void AndroidWebSocketImpl::SendFrame(const std::string& message) {
+AndroidDeviceManager::AndroidWebSocket::~AndroidWebSocket() {
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) {
- DCHECK(thread_checker_.CalledOnValidThread());
- if (!socket_)
- return;
- int mask = base::RandInt(0, 0x7FFFFFFF);
- std::string encoded_frame = WebSocket::EncodeFrameHybi17(message, mask);
- request_buffer_ += encoded_frame;
- if (request_buffer_.length() == encoded_frame.length())
- SendPendingRequests(0);
+ device_->device_message_loop_->DeleteSoon(FROM_HERE, socket_impl_);
dgozman 2014/10/03 19:25:16 if (socket_impl_) ...
vkuzkokov 2014/10/06 14:31:43 Done.
}
-AndroidWebSocketImpl::~AndroidWebSocketImpl() {
+void AndroidDeviceManager::AndroidWebSocket::SendFrame(
+ const std::string& message) {
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();
+ device_->device_message_loop_->PostTask(
dgozman 2014/10/03 19:25:17 DCHECK(socket_impl_)
vkuzkokov 2014/10/06 14:31:43 Done.
+ FROM_HERE,
+ base::Bind(&WebSocketImpl::SendFrame,
+ base::Unretained(socket_impl_), message));
}
-void AndroidWebSocketImpl::Connected(int result,
- scoped_ptr<net::StreamSocket> socket) {
+void AndroidDeviceManager::AndroidWebSocket::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(
+ 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(connection_)));
- OnSocketOpened();
-}
-
-void WebSocketImpl::StartListening() {
- DCHECK(thread_checker_.CalledOnValidThread());
- DCHECK(socket_);
- scoped_refptr<net::IOBuffer> response_buffer =
- new net::IOBuffer(kBufferSize);
- int 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::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;
- std::string output;
- WebSocket::ParseResult parse_result = WebSocket::DecodeFrameHybi17(
- response_buffer_, false, &bytes_consumed, &output);
-
- while (parse_result == WebSocket::FRAME_OK) {
- response_buffer_ = response_buffer_.substr(bytes_consumed);
- delegate_->OnFrameRead(output);
- parse_result = WebSocket::DecodeFrameHybi17(
- response_buffer_, false, &bytes_consumed, &output);
- }
-
- if (parse_result == WebSocket::FRAME_ERROR ||
- parse_result == WebSocket::FRAME_CLOSE) {
- Disconnect();
- return;
- }
-
- 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) {
- DCHECK(thread_checker_.CalledOnValidThread());
- if (result < 0) {
- Disconnect();
- return;
- }
- request_buffer_ = request_buffer_.substr(result);
- if (request_buffer_.empty())
- return;
-
- scoped_refptr<net::StringIOBuffer> buffer =
- new net::StringIOBuffer(request_buffer_);
- result = socket_->Write(buffer.get(), buffer->size(),
- base::Bind(&WebSocketImpl::SendPendingRequests,
- base::Unretained(this)));
- if (result != net::ERR_IO_PENDING)
- SendPendingRequests(result);
-}
-
-void WebSocketImpl::Disconnect() {
- DCHECK(thread_checker_.CalledOnValidThread());
- socket_.reset();
- delegate_->OnSocketClosed();
-}
-
-void AndroidWebSocketImpl::OnSocketOpened() {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+ 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(
dgozman 2014/10/03 19:25:17 What if you make AndroidWebSocket::Create(device,
vkuzkokov 2014/10/06 14:31:44 Friend declarations will still be needed, especial
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);
}
« no previous file with comments | « chrome/browser/devtools/device/android_device_manager.h ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698