Fix bug in AndroidDeviceManager::DeviceProvider::HttpUpgrade()

chrome/browser/devtools/device/android_web_socket.cc

 // 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.
 
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/rand_util.h"
 #include "chrome/browser/devtools/device/android_device_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/server/web_socket_encoder.h"
 #include "net/socket/stream_socket.h"
 
 using content::BrowserThread;
 using net::WebSocket;
 
 namespace {
 
 const int kBufferSize = 16 * 1024;
 
 }  // namespace
 
 class AndroidDeviceManager::AndroidWebSocket::WebSocketImpl {
  public:
-   WebSocketImpl(scoped_refptr<base::MessageLoopProxy> response_message_loop,
-                 base::WeakPtr<AndroidWebSocket> weak_socket,
-                 const std::string& extensions,
-                 scoped_ptr<net::StreamSocket> socket)
-       : response_message_loop_(response_message_loop),
-         weak_socket_(weak_socket),
-         socket_(socket.Pass()),
-         encoder_(net::WebSocketEncoder::CreateClient(extensions)) {
+  WebSocketImpl(scoped_refptr<base::MessageLoopProxy> response_message_loop,
+                base::WeakPtr<AndroidWebSocket> weak_socket,
+                const std::string& extensions,
+                const std::string& leading_bytes,
+                scoped_ptr<net::StreamSocket> socket)
+      : response_message_loop_(response_message_loop),
+        weak_socket_(weak_socket),
+        socket_(socket.Pass()),
+        encoder_(net::WebSocketEncoder::CreateClient(extensions)),
+        leading_bytes_(leading_bytes) {
     thread_checker_.DetachFromThread();
   }
 
   void StartListening() {
     DCHECK(thread_checker_.CalledOnValidThread());
     DCHECK(socket_);
     scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kBufferSize));
-    Read(buffer);
+    if (leading_bytes_.length()) {
+      leading_bytes_.swap(response_buffer_);
+      ConsumeResponse(buffer);
+    } else {
+      Read(buffer);
+    }
   }
 
   void SendFrame(const std::string& message) {
     DCHECK(thread_checker_.CalledOnValidThread());
     if (!socket_)
       return;
     int mask = base::RandInt(0, 0x7FFFFFFF);
     std::string encoded_frame;
     encoder_->EncodeFrame(message, mask, &encoded_frame);
     request_buffer_ += encoded_frame;
@@ skipping 12 matching lines @@
       OnBytesRead(response_buffer, 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);
+    ConsumeResponse(response_buffer);
+  }
 
+  void ConsumeResponse(scoped_refptr<net::IOBuffer> response_buffer) {
     int bytes_consumed;
     std::string output;
     WebSocket::ParseResult parse_result = encoder_->DecodeFrame(
         response_buffer_, &bytes_consumed, &output);
 
     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));
@@ skipping 35 matching lines @@
         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_;
   scoped_ptr<net::WebSocketEncoder> encoder_;
   std::string response_buffer_;
   std::string request_buffer_;
+  std::string leading_bytes_;
   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.get()),
@@ skipping 21 matching lines @@
   DCHECK(device_);
   device_->message_loop_proxy_->PostTask(
       FROM_HERE,
       base::Bind(&WebSocketImpl::SendFrame,
                  base::Unretained(socket_impl_), message));
 }
 
 void AndroidDeviceManager::AndroidWebSocket::Connected(
     int result,
     const std::string& extensions,
+    const std::string& leading_bytes,
     scoped_ptr<net::StreamSocket> socket) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (result != net::OK || !socket.get()) {
     OnSocketClosed();
     return;
   }
   socket_impl_ = new WebSocketImpl(base::MessageLoopProxy::current(),
-                                   weak_factory_.GetWeakPtr(),
-                                   extensions,
-                                   socket.Pass());
+                                   weak_factory_.GetWeakPtr(), extensions,
+                                   leading_bytes, socket.Pass());
   device_->message_loop_proxy_->PostTask(
       FROM_HERE,
       base::Bind(&WebSocketImpl::StartListening,
                  base::Unretained(socket_impl_)));
   delegate_->OnSocketOpened();
 }
 
 void AndroidDeviceManager::AndroidWebSocket::OnFrameRead(
     const std::string& message) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
@@ skipping 19 matching lines @@
   }
 }
 
 AndroidDeviceManager::AndroidWebSocket*
 AndroidDeviceManager::Device::CreateWebSocket(
     const std::string& socket_name,
     const std::string& url,
     AndroidWebSocket::Delegate* delegate) {
   return new AndroidWebSocket(this, socket_name, url, delegate);
 }