[DevTools] Support permessage-deflate in AndroidWebSocket.

chrome/browser/devtools/device/android_device_manager.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 "chrome/browser/devtools/device/android_device_manager.h"
 
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "net/base/io_buffer.h"
@@ skipping 10 matching lines @@
 
 static const char kModelOffline[] = "Offline";
 
 static const char kHttpGetRequest[] = "GET %s HTTP/1.1\r\n\r\n";
 
 static const char kWebSocketUpgradeRequest[] = "GET %s HTTP/1.1\r\n"
     "Upgrade: WebSocket\r\n"
     "Connection: Upgrade\r\n"
     "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n"
     "Sec-WebSocket-Version: 13\r\n"
+    "%s"
     "\r\n";
 
 static void PostDeviceInfoCallback(
     scoped_refptr<base::MessageLoopProxy> response_message_loop,
     const AndroidDeviceManager::DeviceInfoCallback& callback,
     const AndroidDeviceManager::DeviceInfo& device_info) {
   response_message_loop->PostTask(FROM_HERE, base::Bind(callback, device_info));
 }
 
 static void PostCommandCallback(
     scoped_refptr<base::MessageLoopProxy> response_message_loop,
     const AndroidDeviceManager::CommandCallback& callback,
     int result,
     const std::string& response) {
   response_message_loop->PostTask(FROM_HERE,
                                   base::Bind(callback, result, response));
 }
 
-static void PostSocketCallback(
+static void PostHttpUpgradeCallback(
     scoped_refptr<base::MessageLoopProxy> response_message_loop,
-    const AndroidDeviceManager::SocketCallback& callback,
+    const AndroidDeviceManager::HttpUpgradeCallback& callback,
     int result,
+    const std::string& extensions,
     scoped_ptr<net::StreamSocket> socket) {
   response_message_loop->PostTask(
-      FROM_HERE, base::Bind(callback, result, base::Passed(&socket)));
+      FROM_HERE,
+      base::Bind(callback, result, extensions, base::Passed(&socket)));
 }
 
 class HttpRequest {
  public:
   typedef AndroidDeviceManager::CommandCallback CommandCallback;
-  typedef AndroidDeviceManager::SocketCallback SocketCallback;
+  typedef AndroidDeviceManager::HttpUpgradeCallback HttpUpgradeCallback;
 
   static void CommandRequest(const std::string& request,
                              const CommandCallback& callback,
                              int result,
                              scoped_ptr<net::StreamSocket> socket) {
     if (result != net::OK) {
       callback.Run(result, std::string());
       return;
     }
     new HttpRequest(socket.Pass(), request, callback);
   }
 
-  static void SocketRequest(const std::string& request,
-                            const SocketCallback& callback,
-                            int result,
-                            scoped_ptr<net::StreamSocket> socket) {
+  static void HttpUpgradeRequest(const std::string& request,
+                                 const HttpUpgradeCallback& callback,
+                                 int result,
+                                 scoped_ptr<net::StreamSocket> socket) {
     if (result != net::OK) {
-      callback.Run(result, make_scoped_ptr<net::StreamSocket>(NULL));
+      callback.Run(result, "", make_scoped_ptr<net::StreamSocket>(nullptr));
       return;
     }
     new HttpRequest(socket.Pass(), request, callback);
   }
 
  private:
   HttpRequest(scoped_ptr<net::StreamSocket> socket,
               const std::string& request,
               const CommandCallback& callback)
       : socket_(socket.Pass()),
         command_callback_(callback),
         body_pos_(0) {
     SendRequest(request);
   }
 
   HttpRequest(scoped_ptr<net::StreamSocket> socket,
               const std::string& request,
-              const SocketCallback& callback)
+              const HttpUpgradeCallback& callback)
     : socket_(socket.Pass()),
-      socket_callback_(callback),
+      http_upgrade_callback_(callback),
       body_pos_(0) {
     SendRequest(request);
   }
 
   ~HttpRequest() {
   }
 
   void SendRequest(const std::string& request) {
     scoped_refptr<net::StringIOBuffer> request_buffer =
         new net::StringIOBuffer(request);
@@ skipping 29 matching lines @@
       return;
     if (result == 0) {
       CheckNetResultOrDie(net::ERR_CONNECTION_CLOSED);
       return;
     }
 
     response_ += std::string(response_buffer->data(), result);
     int expected_length = 0;
     if (bytes_total < 0) {
       // TODO(kaznacheev): Use net::HttpResponseHeader to parse the header.
-      size_t content_pos = response_.find("Content-Length:");
-      if (content_pos != std::string::npos) {
-        size_t endline_pos = response_.find("\n", content_pos);
-        if (endline_pos != std::string::npos) {
-          std::string len = response_.substr(content_pos + 15,
-                                             endline_pos - content_pos - 15);
-          base::TrimWhitespace(len, base::TRIM_ALL, &len);
-          if (!base::StringToInt(len, &expected_length)) {
-            CheckNetResultOrDie(net::ERR_FAILED);
-            return;
-          }
+      std::string content_length = ExtractHeader("Content-Length:");
+      if (!content_length.empty()) {
+        if (!base::StringToInt(content_length, &expected_length)) {
+          CheckNetResultOrDie(net::ERR_FAILED);
+          return;
         }
       }
 
       body_pos_ = response_.find("\r\n\r\n");
       if (body_pos_ != std::string::npos) {
         body_pos_ += 4;
         bytes_total = body_pos_ + expected_length;
       }
     }
 
     if (bytes_total == static_cast<int>(response_.length())) {
-      if (!command_callback_.is_null())
+      if (!command_callback_.is_null()) {
         command_callback_.Run(net::OK, response_.substr(body_pos_));
-      else
-        socket_callback_.Run(net::OK, socket_.Pass());
+      } else {
+        http_upgrade_callback_.Run(net::OK,
+            ExtractHeader("Sec-WebSocket-Extensions:"), socket_.Pass());
+      }
       delete this;
       return;
     }
 
     result = socket_->Read(
         response_buffer.get(),
         kBufferSize,
         base::Bind(&HttpRequest::OnResponseData,
                    base::Unretained(this),
                    response_buffer,
                    bytes_total));
     if (result != net::ERR_IO_PENDING)
       OnResponseData(response_buffer, bytes_total, result);
   }
 
+  std::string ExtractHeader(const std::string& header) {
+    size_t start_pos = response_.find(header);
+    if (start_pos == std::string::npos)
+      return std::string();
+
+    size_t endline_pos = response_.find("\n", start_pos);
+    if (endline_pos == std::string::npos)
+      return std::string();
+
+    std::string value = response_.substr(
+        start_pos + header.length(), endline_pos - start_pos - header.length());
+    base::TrimWhitespace(value, base::TRIM_ALL, &value);
+    return value;
+  }
+
   bool CheckNetResultOrDie(int result) {
     if (result >= 0)
       return true;
-    if (!command_callback_.is_null())
+    if (!command_callback_.is_null()) {
       command_callback_.Run(result, std::string());
-    else
-      socket_callback_.Run(result, make_scoped_ptr<net::StreamSocket>(NULL));
+    } else {
+      http_upgrade_callback_.Run(
+          result, "", make_scoped_ptr<net::StreamSocket>(nullptr));
+    }
     delete this;
     return false;
   }
 
   scoped_ptr<net::StreamSocket> socket_;
   std::string response_;
-  AndroidDeviceManager::CommandCallback command_callback_;
-  AndroidDeviceManager::SocketCallback socket_callback_;
+  CommandCallback command_callback_;
+  HttpUpgradeCallback http_upgrade_callback_;
   size_t body_pos_;
 };
 
 class DevicesRequest : public base::RefCountedThreadSafe<DevicesRequest> {
  public:
   typedef AndroidDeviceManager::DeviceInfo DeviceInfo;
   typedef AndroidDeviceManager::DeviceProvider DeviceProvider;
   typedef AndroidDeviceManager::DeviceProviders DeviceProviders;
   typedef AndroidDeviceManager::DeviceDescriptors DeviceDescriptors;
   typedef base::Callback<void(scoped_ptr<DeviceDescriptors>)>
@@ skipping 83 matching lines @@
              socket_name,
              base::Bind(&HttpRequest::CommandRequest,
                         base::StringPrintf(kHttpGetRequest, request.c_str()),
                         callback));
 }
 
 void AndroidDeviceManager::DeviceProvider::HttpUpgrade(
     const std::string& serial,
     const std::string& socket_name,
     const std::string& url,
-    const SocketCallback& callback) {
+    const std::string& extensions,
+    const HttpUpgradeCallback& callback) {
+  std::string extensions_with_new_line =
+      extensions.empty() ? std::string() : extensions + "\r\n";
   OpenSocket(
       serial,
       socket_name,
-      base::Bind(&HttpRequest::SocketRequest,
-                 base::StringPrintf(kWebSocketUpgradeRequest, url.c_str()),
+      base::Bind(&HttpRequest::HttpUpgradeRequest,
+                 base::StringPrintf(kWebSocketUpgradeRequest,
+                                    url.c_str(),
+                                    extensions_with_new_line.c_str()),
                  callback));
 }
 
 void AndroidDeviceManager::DeviceProvider::ReleaseDevice(
     const std::string& serial) {
 }
 
 AndroidDeviceManager::DeviceProvider::DeviceProvider() {
 }
 
@@ skipping 32 matching lines @@
       base::Bind(&DeviceProvider::SendJsonRequest,
                  provider_,
                  serial_,
                  socket_name,
                  request,
                  base::Bind(&PostCommandCallback,
                             base::MessageLoopProxy::current(),
                             callback)));
 }
 
-void AndroidDeviceManager::Device::HttpUpgrade(const std::string& socket_name,
-                                               const std::string& url,
-                                               const SocketCallback& callback) {
+void AndroidDeviceManager::Device::HttpUpgrade(
+    const std::string& socket_name,
+    const std::string& url,
+    const std::string& extensions,
+    const HttpUpgradeCallback& callback) {
   message_loop_proxy_->PostTask(
       FROM_HERE,
       base::Bind(&DeviceProvider::HttpUpgrade,
                  provider_,
                  serial_,
                  socket_name,
                  url,
-                 base::Bind(&PostSocketCallback,
+                 extensions,
+                 base::Bind(&PostHttpUpgradeCallback,
                             base::MessageLoopProxy::current(),
                             callback)));
 }
 
 AndroidDeviceManager::Device::Device(
     scoped_refptr<base::MessageLoopProxy> device_message_loop,
     scoped_refptr<DeviceProvider> provider,
     const std::string& serial)
     : message_loop_proxy_(device_message_loop),
       provider_(provider),
@@ skipping 112 matching lines @@
           it->provider, it->serial);
     } else {
       device = found->second.get();
     }
     response.push_back(device);
     new_devices[it->serial] = device->weak_factory_.GetWeakPtr();
   }
   devices_.swap(new_devices);
   callback.Run(response);
 }