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);
+    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())
+      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_;

[vsevik, 2014/03/11 10:50:44]

Is this is the only place where this field is used?
Can we declare it as a constant in anonymous namespace instead of making a
member field?

+
     std::string devtools_frontend_url = GetFrontendURLInternal(
         id.c_str(),
-        host);
+        host,
+        overridden_frontend_url);
     dictionary->SetString(
         kTargetDevtoolsFrontendUrlField, devtools_frontend_url);
   }
 
   return dictionary;
 }
 
 }  // namespace content