src/content/browser/devtools/devtools_http_handler_impl.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/browser/devtools/devtools_http_handler_impl.h"
   6
   7 #include <algorithm>
   8 #include <utility>
   9
  10 #include "base/bind.h"
  11 #include "base/compiler_specific.h"
  12 #include "base/file_util.h"
  13 #include "base/json/json_writer.h"
  14 #include "base/logging.h"
  15 #include "base/message_loop/message_loop_proxy.h"
  16 #include "base/stl_util.h"
  17 #include "base/strings/string_number_conversions.h"
  18 #include "base/threading/thread.h"
  19 #include "base/values.h"
  20 #include "content/browser/devtools/devtools_browser_target.h"
  21 #include "content/browser/devtools/devtools_protocol.h"
  22 #include "content/browser/devtools/devtools_protocol_constants.h"
  23 #include "content/browser/devtools/devtools_system_info_handler.h"
  24 #include "content/browser/devtools/devtools_tracing_handler.h"
  25 #include "content/browser/devtools/tethering_handler.h"
  26 #include "content/common/devtools_messages.h"
  27 #include "content/public/browser/browser_thread.h"
  28 #include "content/public/browser/devtools_agent_host.h"
  29 #include "content/public/browser/devtools_client_host.h"
  30 #include "content/public/browser/devtools_http_handler_delegate.h"
  31 #include "content/public/browser/devtools_manager.h"
  32 #include "content/public/browser/devtools_target.h"
  33 #include "content/public/common/content_client.h"
  34 #include "content/public/common/url_constants.h"
  35 #include "content/public/common/user_agent.h"
  36 #include "content/public/common/user_agent.h"
  37 #include "grit/devtools_resources_map.h"
  38 #include "net/base/escape.h"
  39 #include "net/base/io_buffer.h"
  40 #include "net/base/ip_endpoint.h"
  41 #include "net/base/net_errors.h"
  42 #include "net/server/http_server_request_info.h"
  43 #include "net/server/http_server_response_info.h"
  44
  45 #if defined(OS_ANDROID)
  46 #include "base/android/build_info.h"
  47 #endif
  48
  49 namespace content {
  50
  51 namespace {
  52
  53 const base::FilePath::CharType kDevToolsActivePortFileName[] =
  54     FILE_PATH_LITERAL("DevToolsActivePort");
  55
  56 const char kDevToolsHandlerThreadName[] = "Chrome_DevToolsHandlerThread";
  57
  58 const char kThumbUrlPrefix[] = "/thumb/";
  59 const char kPageUrlPrefix[] = "/devtools/page/";
  60
  61 const char kTargetIdField[] = "id";
  62 const char kTargetParentIdField[] = "parentId";
  63 const char kTargetTypeField[] = "type";
  64 const char kTargetTitleField[] = "title";
  65 const char kTargetDescriptionField[] = "description";
  66 const char kTargetUrlField[] = "url";
  67 const char kTargetThumbnailUrlField[] = "thumbnailUrl";
  68 const char kTargetFaviconUrlField[] = "faviconUrl";
  69 const char kTargetWebSocketDebuggerUrlField[] = "webSocketDebuggerUrl";
  70 const char kTargetDevtoolsFrontendUrlField[] = "devtoolsFrontendUrl";
  71
  72 // An internal implementation of DevToolsClientHost that delegates
  73 // messages sent for DevToolsClient to a DebuggerShell instance.
  74 class DevToolsClientHostImpl : public DevToolsClientHost {
  75  public:
  76   DevToolsClientHostImpl(base::MessageLoop* message_loop,
  77                          net::HttpServer* server,
  78                          int connection_id)
  79       : message_loop_(message_loop),
  80         server_(server),
  81         connection_id_(connection_id),
  82         is_closed_(false),
  83         detach_reason_("target_closed") {}
  84
  85   virtual ~DevToolsClientHostImpl() {}
  86
  87   // DevToolsClientHost interface
  88   virtual void InspectedContentsClosing() OVERRIDE {
  89     if (is_closed_)
  90       return;
  91     is_closed_ = true;
  92
  93     base::DictionaryValue notification;
  94     notification.SetString(
  95         devtools::Inspector::detached::kParamReason, detach_reason_);
  96     std::string response = DevToolsProtocol::CreateNotification(
  97         devtools::Inspector::detached::kName,
  98         notification.DeepCopy())->Serialize();
  99     message_loop_->PostTask(
 100         FROM_HERE,
 101         base::Bind(&net::HttpServer::SendOverWebSocket,
 102                    server_,
 103                    connection_id_,
 104                    response));
 105
 106     message_loop_->PostTask(
 107         FROM_HERE,
 108         base::Bind(&net::HttpServer::Close, server_, connection_id_));
 109   }
 110
 111   virtual void DispatchOnInspectorFrontend(const std::string& data) OVERRIDE {
 112     message_loop_->PostTask(
 113         FROM_HERE,
 114         base::Bind(&net::HttpServer::SendOverWebSocket,
 115                    server_,
 116                    connection_id_,
 117                    data));
 118   }
 119
 120   virtual void ReplacedWithAnotherClient() OVERRIDE {
 121     detach_reason_ = "replaced_with_devtools";
 122   }
 123
 124  private:
 125   base::MessageLoop* message_loop_;
 126   net::HttpServer* server_;
 127   int connection_id_;
 128   bool is_closed_;
 129   std::string detach_reason_;
 130 };
 131
 132 static bool TimeComparator(const DevToolsTarget* target1,
 133                            const DevToolsTarget* target2) {
 134   return target1->GetLastActivityTime() > target2->GetLastActivityTime();
 135 }
 136
 137 }  // namespace
 138
 139 // static
 140 bool DevToolsHttpHandler::IsSupportedProtocolVersion(
 141     const std::string& version) {
 142   return devtools::IsSupportedProtocolVersion(version);
 143 }
 144
 145 // static
 146 int DevToolsHttpHandler::GetFrontendResourceId(const std::string& name) {
 147   for (size_t i = 0; i < kDevtoolsResourcesSize; ++i) {
 148     if (name == kDevtoolsResources[i].name)
 149       return kDevtoolsResources[i].value;
 150   }
 151   return -1;
 152 }
 153
 154 // static
 155 DevToolsHttpHandler* DevToolsHttpHandler::Start(
 156     const net::StreamListenSocketFactory* socket_factory,
 157     const std::string& frontend_url,
 158     DevToolsHttpHandlerDelegate* delegate,
 159     const base::FilePath& active_port_output_directory) {
 160   DevToolsHttpHandlerImpl* http_handler =
 161       new DevToolsHttpHandlerImpl(socket_factory,
 162                                   frontend_url,
 163                                   delegate,
 164                                   active_port_output_directory);
 165   http_handler->Start();
 166   return http_handler;
 167 }
 168
 169 DevToolsHttpHandlerImpl::~DevToolsHttpHandlerImpl() {
 170   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 171   // Stop() must be called prior to destruction.
 172   DCHECK(server_.get() == NULL);
 173   DCHECK(thread_.get() == NULL);
 174   STLDeleteValues(&target_map_);
 175 }
 176
 177 void DevToolsHttpHandlerImpl::Start() {
 178   if (thread_)
 179     return;
 180   thread_.reset(new base::Thread(kDevToolsHandlerThreadName));
 181   BrowserThread::PostTask(
 182       BrowserThread::FILE, FROM_HERE,
 183       base::Bind(&DevToolsHttpHandlerImpl::StartHandlerThread, this));
 184 }
 185
 186 // Runs on FILE thread.
 187 void DevToolsHttpHandlerImpl::StartHandlerThread() {
 188   base::Thread::Options options;
 189   options.message_loop_type = base::MessageLoop::TYPE_IO;
 190   if (!thread_->StartWithOptions(options)) {
 191     BrowserThread::PostTask(
 192         BrowserThread::UI, FROM_HERE,
 193         base::Bind(&DevToolsHttpHandlerImpl::ResetHandlerThread, this));
 194     return;
 195   }
 196
 197   thread_->message_loop()->PostTask(
 198       FROM_HERE,
 199       base::Bind(&DevToolsHttpHandlerImpl::Init, this));
 200 }
 201
 202 void DevToolsHttpHandlerImpl::ResetHandlerThread() {
 203   thread_.reset();
 204 }
 205
 206 void DevToolsHttpHandlerImpl::ResetHandlerThreadAndRelease() {
 207   ResetHandlerThread();
 208   Release();
 209 }
 210
 211 void DevToolsHttpHandlerImpl::Stop() {
 212   if (!thread_)
 213     return;
 214   BrowserThread::PostTaskAndReply(
 215       BrowserThread::FILE, FROM_HERE,
 216       base::Bind(&DevToolsHttpHandlerImpl::StopHandlerThread, this),
 217       base::Bind(&DevToolsHttpHandlerImpl::ResetHandlerThreadAndRelease, this));
 218 }
 219
 220 GURL DevToolsHttpHandlerImpl::GetFrontendURL() {
 221   net::IPEndPoint ip_address;
 222   if (server_->GetLocalAddress(&ip_address))
 223     return GURL();
 224   return GURL(std::string("http://") + ip_address.ToString() + frontend_url_);
 225 }
 226
 227 static std::string PathWithoutParams(const std::string& path) {
 228   size_t query_position = path.find("?");
 229   if (query_position != std::string::npos)
 230     return path.substr(0, query_position);
 231   return path;
 232 }
 233
 234 static std::string GetMimeType(const std::string& filename) {
 235   if (EndsWith(filename, ".html", false)) {
 236     return "text/html";
 237   } else if (EndsWith(filename, ".css", false)) {
 238     return "text/css";
 239   } else if (EndsWith(filename, ".js", false)) {
 240     return "application/javascript";
 241   } else if (EndsWith(filename, ".png", false)) {
 242     return "image/png";
 243   } else if (EndsWith(filename, ".gif", false)) {
 244     return "image/gif";
 245   } else if (EndsWith(filename, ".json", false)) {
 246     return "application/json";
 247   }
 248   LOG(ERROR) << "GetMimeType doesn't know mime type for: "
 249              << filename
 250              << " text/plain will be returned";
 251   NOTREACHED();
 252   return "text/plain";
 253 }
 254
 255 void DevToolsHttpHandlerImpl::OnHttpRequest(
 256     int connection_id,
 257     const net::HttpServerRequestInfo& info) {
 258   if (info.path.find("/json") == 0) {
 259     BrowserThread::PostTask(
 260         BrowserThread::UI,
 261         FROM_HERE,
 262         base::Bind(&DevToolsHttpHandlerImpl::OnJsonRequestUI,
 263                    this,
 264                    connection_id,
 265                    info));
 266     return;
 267   }
 268
 269   if (info.path.find(kThumbUrlPrefix) == 0) {
 270     // Thumbnail request.
 271     const std::string target_id = info.path.substr(strlen(kThumbUrlPrefix));
 272     DevToolsTarget* target = GetTarget(target_id);
 273     GURL page_url;
 274     if (target)
 275       page_url = target->GetURL();
 276     BrowserThread::PostTask(
 277         BrowserThread::UI,
 278         FROM_HERE,
 279         base::Bind(&DevToolsHttpHandlerImpl::OnThumbnailRequestUI,
 280                    this,
 281                    connection_id,
 282                    page_url));
 283     return;
 284   }
 285
 286   if (info.path == "" || info.path == "/") {
 287     // Discovery page request.
 288     BrowserThread::PostTask(
 289         BrowserThread::UI,
 290         FROM_HERE,
 291         base::Bind(&DevToolsHttpHandlerImpl::OnDiscoveryPageRequestUI,
 292                    this,
 293                    connection_id));
 294     return;
 295   }
 296
 297   if (info.path.find("/devtools/") != 0) {
 298     server_->Send404(connection_id);
 299     return;
 300   }
 301
 302   std::string filename = PathWithoutParams(info.path.substr(10));
 303   std::string mime_type = GetMimeType(filename);
 304
 305   base::FilePath frontend_dir = delegate_->GetDebugFrontendDir();
 306   if (!frontend_dir.empty()) {
 307     base::FilePath path = frontend_dir.AppendASCII(filename);
 308     std::string data;
 309     base::ReadFileToString(path, &data);
 310     server_->Send200(connection_id, data, mime_type);
 311     return;
 312   }
 313   if (delegate_->BundlesFrontendResources()) {
 314     int resource_id = DevToolsHttpHandler::GetFrontendResourceId(filename);
 315     if (resource_id != -1) {
 316       base::StringPiece data = GetContentClient()->GetDataResource(
 317               resource_id, ui::SCALE_FACTOR_NONE);
 318       server_->Send200(connection_id, data.as_string(), mime_type);
 319       return;
 320     }
 321   }
 322   server_->Send404(connection_id);
 323 }
 324
 325 void DevToolsHttpHandlerImpl::OnWebSocketRequest(
 326     int connection_id,
 327     const net::HttpServerRequestInfo& request) {
 328   std::string browser_prefix = "/devtools/browser";
 329   size_t browser_pos = request.path.find(browser_prefix);
 330   if (browser_pos == 0) {
 331     scoped_refptr<DevToolsBrowserTarget> browser_target =
 332         new DevToolsBrowserTarget(server_.get(), connection_id);
 333     browser_target->RegisterDomainHandler(
 334         devtools::Tracing::kName,
 335         new DevToolsTracingHandler(DevToolsTracingHandler::Browser),
 336         true /* handle on UI thread */);
 337     browser_target->RegisterDomainHandler(
 338         TetheringHandler::kDomain,
 339         new TetheringHandler(delegate_.get()),
 340         false /* handle on this thread */);
 341     browser_target->RegisterDomainHandler(
 342         devtools::SystemInfo::kName,
 343         new DevToolsSystemInfoHandler(),
 344         true /* handle on UI thread */);
 345     browser_targets_[connection_id] = browser_target;
 346
 347     server_->AcceptWebSocket(connection_id, request);
 348     return;
 349   }
 350
 351   BrowserThread::PostTask(
 352       BrowserThread::UI,
 353       FROM_HERE,
 354       base::Bind(
 355           &DevToolsHttpHandlerImpl::OnWebSocketRequestUI,
 356           this,
 357           connection_id,
 358           request));
 359 }
 360
 361 void DevToolsHttpHandlerImpl::OnWebSocketMessage(
 362     int connection_id,
 363     const std::string& data) {
 364   BrowserTargets::iterator it = browser_targets_.find(connection_id);
 365   if (it != browser_targets_.end()) {
 366     it->second->HandleMessage(data);
 367     return;
 368   }
 369
 370   BrowserThread::PostTask(
 371       BrowserThread::UI,
 372       FROM_HERE,
 373       base::Bind(
 374           &DevToolsHttpHandlerImpl::OnWebSocketMessageUI,
 375           this,
 376           connection_id,
 377           data));
 378 }
 379
 380 void DevToolsHttpHandlerImpl::OnClose(int connection_id) {
 381   BrowserTargets::iterator it = browser_targets_.find(connection_id);
 382   if (it != browser_targets_.end()) {
 383     it->second->Detach();
 384     browser_targets_.erase(it);
 385     return;
 386   }
 387
 388   BrowserThread::PostTask(
 389       BrowserThread::UI,
 390       FROM_HERE,
 391       base::Bind(
 392           &DevToolsHttpHandlerImpl::OnCloseUI,
 393           this,
 394           connection_id));
 395 }
 396
 397 std::string DevToolsHttpHandlerImpl::GetFrontendURLInternal(
 398     const std::string id,
 399     const std::string& host) {
 400   return base::StringPrintf(
 401       "%s%sws=%s%s%s",
 402       frontend_url_.c_str(),
 403       frontend_url_.find("?") == std::string::npos ? "?" : "&",
 404       host.c_str(),
 405       kPageUrlPrefix,
 406       id.c_str());
 407 }
 408
 409 static bool ParseJsonPath(
 410     const std::string& path,
 411     std::string* command,
 412     std::string* target_id) {
 413
 414   // Fall back to list in case of empty query.
 415   if (path.empty()) {
 416     *command = "list";
 417     return true;
 418   }
 419
 420   if (path.find("/") != 0) {
 421     // Malformed command.
 422     return false;
 423   }
 424   *command = path.substr(1);
 425
 426   size_t separator_pos = command->find("/");
 427   if (separator_pos != std::string::npos) {
 428     *target_id = command->substr(separator_pos + 1);
 429     *command = command->substr(0, separator_pos);
 430   }
 431   return true;
 432 }
 433
 434 void DevToolsHttpHandlerImpl::OnJsonRequestUI(
 435     int connection_id,
 436     const net::HttpServerRequestInfo& info) {
 437   // Trim /json
 438   std::string path = info.path.substr(5);
 439
 440   // Trim fragment and query
 441   std::string query;
 442   size_t query_pos = path.find("?");
 443   if (query_pos != std::string::npos) {
 444     query = path.substr(query_pos + 1);
 445     path = path.substr(0, query_pos);
 446   }
 447
 448   size_t fragment_pos = path.find("#");
 449   if (fragment_pos != std::string::npos)
 450     path = path.substr(0, fragment_pos);
 451
 452   std::string command;
 453   std::string target_id;
 454   if (!ParseJsonPath(path, &command, &target_id)) {
 455     SendJson(connection_id,
 456              net::HTTP_NOT_FOUND,
 457              NULL,
 458              "Malformed query: " + info.path);
 459     return;
 460   }
 461
 462   if (command == "version") {
 463     base::DictionaryValue version;
 464     version.SetString("Protocol-Version", devtools::kProtocolVersion);
 465     version.SetString("WebKit-Version", GetWebKitVersion());
 466     version.SetString("Browser", GetContentClient()->GetProduct());
 467     version.SetString("User-Agent", GetContentClient()->GetUserAgent());
 468 #if defined(OS_ANDROID)
 469     version.SetString("Android-Package",
 470         base::android::BuildInfo::GetInstance()->package_name());
 471 #endif
 472     SendJson(connection_id, net::HTTP_OK, &version, std::string());
 473     return;
 474   }
 475
 476   if (command == "list") {
 477     std::string host = info.headers["host"];
 478     AddRef();  // Balanced in OnTargetListReceived.
 479     delegate_->EnumerateTargets(
 480         base::Bind(&DevToolsHttpHandlerImpl::OnTargetListReceived,
 481                    this, connection_id, host));
 482     return;
 483   }
 484
 485   if (command == "new") {
 486     GURL url(net::UnescapeURLComponent(
 487         query, net::UnescapeRule::URL_SPECIAL_CHARS));
 488     if (!url.is_valid())
 489       url = GURL(url::kAboutBlankURL);
 490     scoped_ptr<DevToolsTarget> target(delegate_->CreateNewTarget(url));
 491     if (!target) {
 492       SendJson(connection_id,
 493                net::HTTP_INTERNAL_SERVER_ERROR,
 494                NULL,
 495                "Could not create new page");
 496       return;
 497     }
 498     std::string host = info.headers["host"];
 499     scoped_ptr<base::DictionaryValue> dictionary(
 500         SerializeTarget(*target.get(), host));
 501     SendJson(connection_id, net::HTTP_OK, dictionary.get(), std::string());
 502     const std::string target_id = target->GetId();
 503     target_map_[target_id] = target.release();
 504     return;
 505   }
 506
 507   if (command == "activate" || command == "close") {
 508     DevToolsTarget* target = GetTarget(target_id);
 509     if (!target) {
 510       SendJson(connection_id,
 511                net::HTTP_NOT_FOUND,
 512                NULL,
 513                "No such target id: " + target_id);
 514       return;
 515     }
 516
 517     if (command == "activate") {
 518       if (target->Activate()) {
 519         SendJson(connection_id, net::HTTP_OK, NULL, "Target activated");
 520       } else {
 521         SendJson(connection_id,
 522                  net::HTTP_INTERNAL_SERVER_ERROR,
 523                  NULL,
 524                  "Could not activate target id: " + target_id);
 525       }
 526       return;
 527     }
 528
 529     if (command == "close") {
 530       if (target->Close()) {
 531         SendJson(connection_id, net::HTTP_OK, NULL, "Target is closing");
 532       } else {
 533         SendJson(connection_id,
 534                  net::HTTP_INTERNAL_SERVER_ERROR,
 535                  NULL,
 536                  "Could not close target id: " + target_id);
 537       }
 538       return;
 539     }
 540   }
 541   SendJson(connection_id,
 542            net::HTTP_NOT_FOUND,
 543            NULL,
 544            "Unknown command: " + command);
 545   return;
 546 }
 547
 548 void DevToolsHttpHandlerImpl::OnTargetListReceived(
 549     int connection_id,
 550     const std::string& host,
 551     const DevToolsHttpHandlerDelegate::TargetList& targets) {
 552   DevToolsHttpHandlerDelegate::TargetList sorted_targets = targets;
 553   std::sort(sorted_targets.begin(), sorted_targets.end(), TimeComparator);
 554
 555   STLDeleteValues(&target_map_);
 556   base::ListValue list_value;
 557   for (DevToolsHttpHandlerDelegate::TargetList::const_iterator it =
 558       sorted_targets.begin(); it != sorted_targets.end(); ++it) {
 559     DevToolsTarget* target = *it;
 560     target_map_[target->GetId()] = target;
 561     list_value.Append(SerializeTarget(*target, host));
 562   }
 563   SendJson(connection_id, net::HTTP_OK, &list_value, std::string());
 564   Release();  // Balanced in OnJsonRequestUI.
 565 }
 566
 567 DevToolsTarget* DevToolsHttpHandlerImpl::GetTarget(const std::string& id) {
 568   TargetMap::const_iterator it = target_map_.find(id);
 569   if (it == target_map_.end())
 570     return NULL;
 571   return it->second;
 572 }
 573
 574 void DevToolsHttpHandlerImpl::OnThumbnailRequestUI(
 575     int connection_id, const GURL& page_url) {
 576   std::string data = delegate_->GetPageThumbnailData(page_url);
 577   if (!data.empty())
 578     Send200(connection_id, data, "image/png");
 579   else
 580     Send404(connection_id);
 581 }
 582
 583 void DevToolsHttpHandlerImpl::OnDiscoveryPageRequestUI(int connection_id) {
 584   std::string response = delegate_->GetDiscoveryPageHTML();
 585   Send200(connection_id, response, "text/html; charset=UTF-8");
 586 }
 587
 588 void DevToolsHttpHandlerImpl::OnWebSocketRequestUI(
 589     int connection_id,
 590     const net::HttpServerRequestInfo& request) {
 591   if (!thread_)
 592     return;
 593
 594   size_t pos = request.path.find(kPageUrlPrefix);
 595   if (pos != 0) {
 596     Send404(connection_id);
 597     return;
 598   }
 599
 600   std::string page_id = request.path.substr(strlen(kPageUrlPrefix));
 601   DevToolsTarget* target = GetTarget(page_id);
 602   scoped_refptr<DevToolsAgentHost> agent =
 603       target ? target->GetAgentHost() : NULL;
 604   if (!agent) {
 605     Send500(connection_id, "No such target id: " + page_id);
 606     return;
 607   }
 608
 609   if (agent->IsAttached()) {
 610     Send500(connection_id,
 611             "Target with given id is being inspected: " + page_id);
 612     return;
 613   }
 614
 615   DevToolsClientHostImpl* client_host = new DevToolsClientHostImpl(
 616       thread_->message_loop(), server_.get(), connection_id);
 617   connection_to_client_host_ui_[connection_id] = client_host;
 618
 619   DevToolsManager::GetInstance()->
 620       RegisterDevToolsClientHostFor(agent, client_host);
 621
 622   AcceptWebSocket(connection_id, request);
 623 }
 624
 625 void DevToolsHttpHandlerImpl::OnWebSocketMessageUI(
 626     int connection_id,
 627     const std::string& data) {
 628   ConnectionToClientHostMap::iterator it =
 629       connection_to_client_host_ui_.find(connection_id);
 630   if (it == connection_to_client_host_ui_.end())
 631     return;
 632
 633   DevToolsManager* manager = DevToolsManager::GetInstance();
 634   manager->DispatchOnInspectorBackend(it->second, data);
 635 }
 636
 637 void DevToolsHttpHandlerImpl::OnCloseUI(int connection_id) {
 638   ConnectionToClientHostMap::iterator it =
 639       connection_to_client_host_ui_.find(connection_id);
 640   if (it != connection_to_client_host_ui_.end()) {
 641     DevToolsClientHostImpl* client_host =
 642         static_cast<DevToolsClientHostImpl*>(it->second);
 643     DevToolsManager::GetInstance()->ClientHostClosing(client_host);
 644     delete client_host;
 645     connection_to_client_host_ui_.erase(connection_id);
 646   }
 647 }
 648
 649 DevToolsHttpHandlerImpl::DevToolsHttpHandlerImpl(
 650     const net::StreamListenSocketFactory* socket_factory,
 651     const std::string& frontend_url,
 652     DevToolsHttpHandlerDelegate* delegate,
 653     const base::FilePath& active_port_output_directory)
 654     : frontend_url_(frontend_url),
 655       socket_factory_(socket_factory),
 656       delegate_(delegate),
 657       active_port_output_directory_(active_port_output_directory) {
 658   if (frontend_url_.empty())
 659       frontend_url_ = "/devtools/devtools.html";
 660
 661   // Balanced in ResetHandlerThreadAndRelease().
 662   AddRef();
 663 }
 664
 665 // Runs on the handler thread
 666 void DevToolsHttpHandlerImpl::Init() {
 667   server_ = new net::HttpServer(*socket_factory_.get(), this);
 668   if (!active_port_output_directory_.empty())
 669     WriteActivePortToUserProfile();
 670 }
 671
 672 // Runs on the handler thread
 673 void DevToolsHttpHandlerImpl::Teardown() {
 674   server_ = NULL;
 675 }
 676
 677 // Runs on FILE thread to make sure that it is serialized against
 678 // {Start|Stop}HandlerThread and to allow calling pthread_join.
 679 void DevToolsHttpHandlerImpl::StopHandlerThread() {
 680   if (!thread_->message_loop())
 681     return;
 682   thread_->message_loop()->PostTask(
 683       FROM_HERE,
 684       base::Bind(&DevToolsHttpHandlerImpl::Teardown, this));
 685   // Thread::Stop joins the thread.
 686   thread_->Stop();
 687 }
 688
 689 void DevToolsHttpHandlerImpl::WriteActivePortToUserProfile() {
 690   DCHECK(!active_port_output_directory_.empty());
 691   net::IPEndPoint endpoint;
 692   int err;
 693   if ((err = server_->GetLocalAddress(&endpoint)) != net::OK) {
 694     LOG(ERROR) << "Error " << err << " getting local address";
 695     return;
 696   }
 697
 698   // Write this port to a well-known file in the profile directory
 699   // so Telemetry can pick it up.
 700   base::FilePath path = active_port_output_directory_.Append(
 701       kDevToolsActivePortFileName);
 702   std::string port_string = base::IntToString(endpoint.port());
 703   if (base::WriteFile(path, port_string.c_str(), port_string.length()) < 0) {
 704     LOG(ERROR) << "Error writing DevTools active port to file";
 705   }
 706 }
 707
 708 void DevToolsHttpHandlerImpl::SendJson(int connection_id,
 709                                        net::HttpStatusCode status_code,
 710                                        base::Value* value,
 711                                        const std::string& message) {
 712   if (!thread_)
 713     return;
 714
 715   // Serialize value and message.
 716   std::string json_value;
 717   if (value) {
 718     base::JSONWriter::WriteWithOptions(value,
 719                                        base::JSONWriter::OPTIONS_PRETTY_PRINT,
 720                                        &json_value);
 721   }
 722   std::string json_message;
 723   scoped_ptr<base::Value> message_object(new base::StringValue(message));
 724   base::JSONWriter::Write(message_object.get(), &json_message);
 725
 726   net::HttpServerResponseInfo response(status_code);
 727   response.SetBody(json_value + message, "application/json; charset=UTF-8");
 728
 729   thread_->message_loop()->PostTask(
 730       FROM_HERE,
 731       base::Bind(&net::HttpServer::SendResponse,
 732                  server_.get(),
 733                  connection_id,
 734                  response));
 735 }
 736
 737 void DevToolsHttpHandlerImpl::Send200(int connection_id,
 738                                       const std::string& data,
 739                                       const std::string& mime_type) {
 740   if (!thread_)
 741     return;
 742   thread_->message_loop()->PostTask(
 743       FROM_HERE,
 744       base::Bind(&net::HttpServer::Send200,
 745                  server_.get(),
 746                  connection_id,
 747                  data,
 748                  mime_type));
 749 }
 750
 751 void DevToolsHttpHandlerImpl::Send404(int connection_id) {
 752   if (!thread_)
 753     return;
 754   thread_->message_loop()->PostTask(
 755       FROM_HERE,
 756       base::Bind(&net::HttpServer::Send404, server_.get(), connection_id));
 757 }
 758
 759 void DevToolsHttpHandlerImpl::Send500(int connection_id,
 760                                       const std::string& message) {
 761   if (!thread_)
 762     return;
 763   thread_->message_loop()->PostTask(
 764       FROM_HERE,
 765       base::Bind(&net::HttpServer::Send500, server_.get(), connection_id,
 766                  message));
 767 }
 768
 769 void DevToolsHttpHandlerImpl::AcceptWebSocket(
 770     int connection_id,
 771     const net::HttpServerRequestInfo& request) {
 772   if (!thread_)
 773     return;
 774   thread_->message_loop()->PostTask(
 775       FROM_HERE,
 776       base::Bind(&net::HttpServer::AcceptWebSocket, server_.get(),
 777                  connection_id, request));
 778 }
 779
 780 base::DictionaryValue* DevToolsHttpHandlerImpl::SerializeTarget(
 781     const DevToolsTarget& target,
 782     const std::string& host) {
 783   base::DictionaryValue* dictionary = new base::DictionaryValue;
 784
 785   std::string id = target.GetId();
 786   dictionary->SetString(kTargetIdField, id);
 787   std::string parent_id = target.GetParentId();
 788   if (!parent_id.empty())
 789     dictionary->SetString(kTargetParentIdField, parent_id);
 790   dictionary->SetString(kTargetTypeField, target.GetType());
 791   dictionary->SetString(kTargetTitleField,
 792                         net::EscapeForHTML(target.GetTitle()));
 793   dictionary->SetString(kTargetDescriptionField, target.GetDescription());
 794
 795   GURL url = target.GetURL();
 796   dictionary->SetString(kTargetUrlField, url.spec());
 797
 798   GURL favicon_url = target.GetFaviconURL();
 799   if (favicon_url.is_valid())
 800     dictionary->SetString(kTargetFaviconUrlField, favicon_url.spec());
 801
 802   if (!delegate_->GetPageThumbnailData(url).empty()) {
 803     dictionary->SetString(kTargetThumbnailUrlField,
 804                           std::string(kThumbUrlPrefix) + id);
 805   }
 806
 807   if (!target.IsAttached()) {
 808     dictionary->SetString(kTargetWebSocketDebuggerUrlField,
 809                           base::StringPrintf("ws://%s%s%s",
 810                                              host.c_str(),
 811                                              kPageUrlPrefix,
 812                                              id.c_str()));
 813     std::string devtools_frontend_url = GetFrontendURLInternal(
 814         id.c_str(),
 815         host);
 816     dictionary->SetString(
 817         kTargetDevtoolsFrontendUrlField, devtools_frontend_url);
 818   }
 819
 820   return dictionary;
 821 }
 822
 823 }  // namespace content