[DevTools] Respond with a close frame

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 <utility>
 
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/rand_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.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;
+const char kCloseResponse[] = "\x88\x80\x2D\x0E\x1E\xFA";
 
 }  // namespace
 
 class AndroidDeviceManager::AndroidWebSocket::WebSocketImpl {
  public:
   WebSocketImpl(
       scoped_refptr<base::SingleThreadTaskRunner> response_task_runner,
       base::WeakPtr<AndroidWebSocket> weak_socket,
       const std::string& extensions,
       const std::string& body_head,
@@ skipping 19 matching lines @@
   }
 
   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;
     if (request_buffer_.length() == encoded_frame.length())

[dgozman, 2017/05/09 23:00:38]

Let's add SendData(const std::string& data) which will do this check and reuse
it here and for close response.

[eostroukhov, 2017/05/09 23:53:14]

Done.

       SendPendingRequests(0);
   }
 
  private:
   void Read(scoped_refptr<net::IOBuffer> io_buffer) {
     int result = socket_->Read(
         io_buffer.get(),
         kBufferSize,
         base::Bind(&WebSocketImpl::OnBytesRead,
                    base::Unretained(this), io_buffer));
@@ skipping 19 matching lines @@
         response_buffer_, &bytes_consumed, &output);
 
     while (parse_result == WebSocket::FRAME_OK) {
       response_buffer_ = response_buffer_.substr(bytes_consumed);
       response_task_runner_->PostTask(
           FROM_HERE,
           base::BindOnce(&AndroidWebSocket::OnFrameRead, weak_socket_, output));
       parse_result = encoder_->DecodeFrame(
           response_buffer_, &bytes_consumed, &output);
     }
+    if (parse_result == WebSocket::FRAME_CLOSE)
+      SendCloseResponse();
 
-    if (parse_result == WebSocket::FRAME_ERROR ||
-        parse_result == WebSocket::FRAME_CLOSE) {
+    if (parse_result == WebSocket::FRAME_ERROR) {
       Disconnect();
       return;
     }
     Read(io_buffer);
   }
 
+  void SendCloseResponse() {
+    request_buffer_ += kCloseResponse;
+    if (request_buffer_.length() == arraysize(kCloseResponse) - 1)
+      SendPendingRequests(0);
+  }
+
   void SendPendingRequests(int result) {
     DCHECK(thread_checker_.CalledOnValidThread());
     if (result < 0) {
       Disconnect();
       return;
     }
     request_buffer_ = request_buffer_.substr(result);
     if (request_buffer_.empty())
       return;
 
@@ skipping 87 matching lines @@
   delegate_->OnSocketClosed();
 }
 
 AndroidDeviceManager::AndroidWebSocket*
 AndroidDeviceManager::Device::CreateWebSocket(
     const std::string& socket_name,
     const std::string& path,
     AndroidWebSocket::Delegate* delegate) {
   return new AndroidWebSocket(this, socket_name, path, delegate);
 }