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