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

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 34 matching lines @@
     const std::string& response) {
   response_message_loop->PostTask(FROM_HERE,
                                   base::Bind(callback, result, response));
 }
 
 static void PostHttpUpgradeCallback(
     scoped_refptr<base::MessageLoopProxy> response_message_loop,
     const AndroidDeviceManager::HttpUpgradeCallback& callback,
     int result,
     const std::string& extensions,
+    const std::string& leading_bytes,
     scoped_ptr<net::StreamSocket> socket) {
   response_message_loop->PostTask(
-      FROM_HERE,
-      base::Bind(callback, result, extensions, base::Passed(&socket)));
+      FROM_HERE, base::Bind(callback, result, extensions, leading_bytes,
+                            base::Passed(&socket)));
 }
 
 class HttpRequest {
  public:
   typedef AndroidDeviceManager::CommandCallback CommandCallback;
   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 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>(nullptr));
+      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()),
@@ skipping 64 matching lines @@
         }
       }
 
       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()) {
-        command_callback_.Run(net::OK, response_.substr(body_pos_));
-      } else {
-        http_upgrade_callback_.Run(net::OK,
-            ExtractHeader("Sec-WebSocket-Extensions:"), socket_.Pass());
-      }
+    if (!command_callback_.is_null() &&
+        bytes_total == static_cast<int>(response_.length())) {
+      command_callback_.Run(net::OK, response_.substr(body_pos_));
       delete this;
       return;
     }
+
+    if (!http_upgrade_callback_.is_null() && body_pos_ != std::string::npos &&
+        body_pos_ > 0) {
+      http_upgrade_callback_.Run(net::OK,
+                                 ExtractHeader("Sec-WebSocket-Extensions:"),
+                                 response_.substr(body_pos_), 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);
@@ skipping 13 matching lines @@
     base::TrimWhitespace(value, base::TRIM_ALL, &value);
     return value;
   }
 
   bool CheckNetResultOrDie(int result) {
     if (result >= 0)
       return true;
     if (!command_callback_.is_null()) {
       command_callback_.Run(result, std::string());
     } else {
-      http_upgrade_callback_.Run(
-          result, "", make_scoped_ptr<net::StreamSocket>(nullptr));
+      http_upgrade_callback_.Run(result, "", "",
+                                 make_scoped_ptr<net::StreamSocket>(nullptr));
     }
     delete this;
     return false;
   }
 
   scoped_ptr<net::StreamSocket> socket_;
   std::string response_;
   CommandCallback command_callback_;
   HttpUpgradeCallback http_upgrade_callback_;
   size_t body_pos_;
@@ skipping 301 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);
 }