DevTools: remove the --remote-debugging-frontend flag.

content/browser/devtools/devtools_http_handler_impl.cc

 // Copyright (c) 2012 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 "content/browser/devtools/devtools_http_handler_impl.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 198 matching lines @@
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&DevToolsHttpHandlerImpl::StopHandlerThread, this),
       base::Bind(&DevToolsHttpHandlerImpl::ResetHandlerThreadAndRelease, this));
 }
 
 GURL DevToolsHttpHandlerImpl::GetFrontendURL() {
   net::IPEndPoint ip_address;
   if (server_->GetLocalAddress(&ip_address))
     return GURL();
   return GURL(std::string("http://") + ip_address.ToString() +
-      overridden_frontend_url_);
+      frontend_url_);
 }
 
 static std::string PathWithoutParams(const std::string& path) {
   size_t query_position = path.find("?");
   if (query_position != std::string::npos)
     return path.substr(0, query_position);
   return path;
 }
 
 static std::string GetMimeType(const std::string& filename) {
@@ skipping 150 matching lines @@
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(
           &DevToolsHttpHandlerImpl::OnCloseUI,
           this,
           connection_id));
 }
 
 std::string DevToolsHttpHandlerImpl::GetFrontendURLInternal(
     const std::string id,
-    const std::string& host) {
+    const std::string& host,
+    const std::string& frontend_url) {
   return base::StringPrintf(
       "%s%sws=%s%s%s",
-      overridden_frontend_url_.c_str(),
-      overridden_frontend_url_.find("?") == std::string::npos ? "?" : "&",
+      frontend_url.c_str(),
+      frontend_url.find("?") == std::string::npos ? "?" : "&",
       host.c_str(),
       kPageUrlPrefix,
       id.c_str());
 }
 
 static bool ParseJsonPath(
     const std::string& path,
     std::string* command,
     std::string* target_id) {
 
@@ skipping 17 matching lines @@
   return true;
 }
 
 void DevToolsHttpHandlerImpl::OnJsonRequestUI(
     int connection_id,
     const net::HttpServerRequestInfo& info) {
   // Trim /json
   std::string path = info.path.substr(5);
 
   // Trim fragment and query
-  std::string query;
+  GURL aux_url;
   size_t query_pos = path.find("?");
   if (query_pos != std::string::npos) {
-    query = path.substr(query_pos + 1);

[lushnikov, 2014/03/08 15:15:18]

what kind of query could be passed in here before?

[pfeldman, 2014/03/08 15:46:29]

The only usage was passing the url to open in the new tab (line 478). For now we
only pass urls as aux parameters, so the implementation can be this bare.

+    std::string query = path.substr(query_pos + 1);
     path = path.substr(0, query_pos);
+
+    aux_url = GURL(net::UnescapeURLComponent(
+        query, net::UnescapeRule::URL_SPECIAL_CHARS));
   }
 
   size_t fragment_pos = path.find("#");
   if (fragment_pos != std::string::npos)
     path = path.substr(0, fragment_pos);
 
   std::string command;
   std::string target_id;
   if (!ParseJsonPath(path, &command, &target_id)) {
     SendJson(connection_id,
@@ skipping 16 matching lines @@
 #endif
     SendJson(connection_id, net::HTTP_OK, &version, std::string());
     return;
   }
 
   if (command == "list") {
     std::string host = info.headers["host"];
     AddRef();  // Balanced in OnTargetListReceived.
     delegate_->EnumerateTargets(
         base::Bind(&DevToolsHttpHandlerImpl::OnTargetListReceived,
-                   this, connection_id, host));
+                   this, connection_id, host, aux_url));
     return;
   }
 
   if (command == "new") {
-    GURL url(net::UnescapeURLComponent(
-        query, net::UnescapeRule::URL_SPECIAL_CHARS));
-    if (!url.is_valid())
-      url = GURL(kAboutBlankURL);
-    scoped_ptr<DevToolsTarget> target(delegate_->CreateNewTarget(url));
+    if (aux_url.is_valid())

[lushnikov, 2014/03/08 15:15:18]

"not" seems to be missing here

[pfeldman, 2014/03/08 15:46:29]

... and i was so happy i did it w/o the help from compiler. On a positive note,
there was a test for it.

Done!

+      aux_url = GURL(kAboutBlankURL);
+    scoped_ptr<DevToolsTarget> target(delegate_->CreateNewTarget(aux_url));
     if (!target) {
       SendJson(connection_id,
                net::HTTP_INTERNAL_SERVER_ERROR,
                NULL,
                "Could not create new page");
       return;
     }
     std::string host = info.headers["host"];
     scoped_ptr<base::DictionaryValue> dictionary(
-        SerializeTarget(*target.get(), host));
+        SerializeTarget(*target.get(), host, aux_url));
     SendJson(connection_id, net::HTTP_OK, dictionary.get(), std::string());
     const std::string target_id = target->GetId();
     target_map_[target_id] = target.release();
     return;
   }
 
   if (command == "activate" || command == "close") {
     DevToolsTarget* target = GetTarget(target_id);
     if (!target) {
       SendJson(connection_id,
@@ skipping 30 matching lines @@
   SendJson(connection_id,
            net::HTTP_NOT_FOUND,
            NULL,
            "Unknown command: " + command);
   return;
 }
 
 void DevToolsHttpHandlerImpl::OnTargetListReceived(
     int connection_id,
     const std::string& host,
+    const GURL& aux_url,
     const DevToolsHttpHandlerDelegate::TargetList& targets) {
   DevToolsHttpHandlerDelegate::TargetList sorted_targets = targets;
   std::sort(sorted_targets.begin(), sorted_targets.end(), TimeComparator);
 
   STLDeleteValues(&target_map_);
   base::ListValue list_value;
   for (DevToolsHttpHandlerDelegate::TargetList::const_iterator it =
       sorted_targets.begin(); it != sorted_targets.end(); ++it) {
     DevToolsTarget* target = *it;
     target_map_[target->GetId()] = target;
-    list_value.Append(SerializeTarget(*target, host));
+    list_value.Append(SerializeTarget(*target, host, aux_url));
   }
   SendJson(connection_id, net::HTTP_OK, &list_value, std::string());
   Release();  // Balanced in OnJsonRequestUI.
 }
 
 DevToolsTarget* DevToolsHttpHandlerImpl::GetTarget(const std::string& id) {
   TargetMap::const_iterator it = target_map_.find(id);
   if (it == target_map_.end())
     return NULL;
   return it->second;
@@ skipping 71 matching lines @@
     DevToolsManager::GetInstance()->ClientHostClosing(client_host);
     delete client_host;
     connection_to_client_host_ui_.erase(connection_id);
   }
 }
 
 DevToolsHttpHandlerImpl::DevToolsHttpHandlerImpl(
     const net::StreamListenSocketFactory* socket_factory,
     const std::string& frontend_url,
     DevToolsHttpHandlerDelegate* delegate)
-    : overridden_frontend_url_(frontend_url),
+    : frontend_url_(frontend_url),
       socket_factory_(socket_factory),
       delegate_(delegate) {
-  if (overridden_frontend_url_.empty())
-      overridden_frontend_url_ = "/devtools/devtools.html";
+  if (frontend_url_.empty())
+      frontend_url_ = "/devtools/devtools.html";
 
   // Balanced in ResetHandlerThreadAndRelease().
   AddRef();
 }
 
 // Runs on the handler thread
 void DevToolsHttpHandlerImpl::Init() {
   server_ = new net::HttpServer(*socket_factory_.get(), this);
 }
 
@@ skipping 81 matching lines @@
   if (!thread_)
     return;
   thread_->message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&net::HttpServer::AcceptWebSocket, server_.get(),
                  connection_id, request));
 }
 
 base::DictionaryValue* DevToolsHttpHandlerImpl::SerializeTarget(
     const DevToolsTarget& target,
-    const std::string& host) {
+    const std::string& host,
+    const GURL& aux_url) {
   base::DictionaryValue* dictionary = new base::DictionaryValue;
 
   std::string id = target.GetId();
   dictionary->SetString(kTargetIdField, id);
   dictionary->SetString(kTargetTypeField, target.GetType());
   dictionary->SetString(kTargetTitleField,
                         net::EscapeForHTML(target.GetTitle()));
   dictionary->SetString(kTargetDescriptionField, target.GetDescription());
 
   GURL url = target.GetUrl();
   dictionary->SetString(kTargetUrlField, url.spec());
 
   GURL favicon_url = target.GetFaviconUrl();
   if (favicon_url.is_valid())
     dictionary->SetString(kTargetFaviconUrlField, favicon_url.spec());
 
   if (!delegate_->GetPageThumbnailData(url).empty()) {
     dictionary->SetString(kTargetThumbnailUrlField,
                           std::string(kThumbUrlPrefix) + id);
   }
 
   if (!target.IsAttached()) {
     dictionary->SetString(kTargetWebSocketDebuggerUrlField,
                           base::StringPrintf("ws://%s%s%s",
                                              host.c_str(),
                                              kPageUrlPrefix,
                                              id.c_str()));
+    std::string overridden_frontend_url =
+        aux_url.is_valid() ? aux_url.spec() : frontend_url_;
+
     std::string devtools_frontend_url = GetFrontendURLInternal(
         id.c_str(),
-        host);
+        host,
+        overridden_frontend_url);
     dictionary->SetString(
         kTargetDevtoolsFrontendUrlField, devtools_frontend_url);
   }
 
   return dictionary;
 }
 
 }  // namespace content