DevTools: do not use debug target when loading URLs for the front-end (chrome side).

chrome/browser/devtools/devtools_ui_bindings.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/devtools_ui_bindings.h"
 
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/metrics/histogram.h"
@@ skipping 29 matching lines @@
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/common/renderer_preferences.h"
 #include "content/public/common/url_constants.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/common/permissions/permissions_data.h"
+#include "net/http/http_response_headers.h"
+#include "net/url_request/url_fetcher.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/page_transition_types.h"
 
 using base::DictionaryValue;
 using content::BrowserThread;
 
 namespace content {
 struct LoadCommittedDetails;
 struct FrameNavigateParams;
 }
@@ skipping 399 matching lines @@
 }
 
 void DevToolsUIBindings::AgentHostClosed(
     content::DevToolsAgentHost* agent_host,
     bool replaced_with_another_client) {
   DCHECK(agent_host == agent_host_.get());
   agent_host_ = NULL;
   delegate_->InspectedContentsClosing();
 }
 
-void DevToolsUIBindings::SendMessageAck(int request_id) {
+void DevToolsUIBindings::SendMessageAck(int request_id,
+                                        const base::Value* arg) {
   base::FundamentalValue id_value(request_id);
   CallClientFunction("DevToolsAPI.embedderMessageAck",
-                     &id_value, nullptr, nullptr);
+                     &id_value, arg, nullptr);
 }
 
 // DevToolsEmbedderMessageDispatcher::Delegate implementation -----------------
 void DevToolsUIBindings::ActivateWindow(int request_id) {
   delegate_->ActivateWindow();
 }
 
 void DevToolsUIBindings::CloseWindow(int request_id) {
   delegate_->CloseWindow();
 }
 
 void DevToolsUIBindings::LoadCompleted(int request_id) {
   FrontendLoaded();
 }
 
 void DevToolsUIBindings::SetInspectedPageBounds(int request_id,
                                                 const gfx::Rect& rect) {
   delegate_->SetInspectedPageBounds(rect);
 }
 
 void DevToolsUIBindings::SetIsDocked(int request_id, bool dock_requested) {
   delegate_->SetIsDocked(dock_requested);
-  SendMessageAck(request_id);
+  SendMessageAck(request_id, nullptr);
 }
 
 void DevToolsUIBindings::InspectElementCompleted(int request_id) {
   delegate_->InspectElementCompleted();
 }
 
 void DevToolsUIBindings::InspectedURLChanged(int request_id,
                                              const std::string& url) {
   content::NavigationController& controller = web_contents()->GetController();
   content::NavigationEntry* entry = controller.GetActiveEntry();
   // DevTools UI is not localized.
   entry->SetTitle(
       base::UTF8ToUTF16(base::StringPrintf(kTitleFormat, url.c_str())));
   web_contents()->NotifyNavigationStateChanged(content::INVALIDATE_TYPE_TITLE);
 }
 
+void DevToolsUIBindings::LoadNetworkResource(int request_id,
+                                             const std::string& url,
+                                             const std::string& headers) {
+  GURL gurl(url);
+  if (!gurl.is_valid()) {
+    base::DictionaryValue response;
+    response.SetInteger("statusCode", 404);
+    SendMessageAck(request_id, &response);
+    return;
+  }
+
+  net::URLFetcher* fetcher =
+      net::URLFetcher::Create(gurl, net::URLFetcher::GET, this);

[dgozman, 2015/02/27 12:22:04]

You should delete all pending fetchers in destructor, or they will access dead
|this|.

[pfeldman, 2015/02/27 12:54:47]

Ouch. Done.

+  pending_requests_[fetcher] = request_id;
+  fetcher->SetRequestContext(profile_->GetRequestContext());
+  fetcher->SetExtraRequestHeaders(headers);
+  fetcher->Start();
+}
+
 void DevToolsUIBindings::OpenInNewTab(int request_id, const std::string& url) {
   delegate_->OpenInNewTab(url);
 }
 
 void DevToolsUIBindings::SaveToFile(int request_id,
                                     const std::string& url,
                                     const std::string& content,
                                     bool save_as) {
   file_helper_->Save(url, content, save_as,
                      base::Bind(&DevToolsUIBindings::FileSavedAs,
@@ skipping 175 matching lines @@
 
 void DevToolsUIBindings::RecordActionUMA(int request_id,
                                          const std::string& name,
                                          int action) {
   if (name == kDevToolsActionTakenHistogram)
     UMA_HISTOGRAM_ENUMERATION(name, action, kDevToolsActionTakenBoundary);
   else if (name == kDevToolsPanelShownHistogram)
     UMA_HISTOGRAM_ENUMERATION(name, action, kDevToolsPanelShownBoundary);
 }
 
+void DevToolsUIBindings::OnURLFetchComplete(const net::URLFetcher* source) {
+  DCHECK(source);
+  PendingRequestsMap::iterator it = pending_requests_.find(source);
+  DCHECK(it != pending_requests_.end());
+
+  std::string body;
+  source->GetResponseAsString(&body);
+
+  base::FundamentalValue request_id(it->second);
+
+  base::DictionaryValue response;
+  base::DictionaryValue* headers = new base::DictionaryValue();
+  net::HttpResponseHeaders* rh = source->GetResponseHeaders();
+  response.SetInteger("statusCode", rh ? rh->response_code() : 200);
+  response.Set("headers", headers);
+  response.SetString("body", body);
+
+  void* iterator = NULL;
+  std::string name;
+  std::string value;
+  while (rh && rh->EnumerateHeaderLines(&iterator, &name, &value))
+    headers->SetString(name, value);
+
+  SendMessageAck(it->second, &response);
+  pending_requests_.erase(it);
+}
+
 void DevToolsUIBindings::DeviceCountChanged(int count) {
   base::FundamentalValue value(count);
   CallClientFunction("DevToolsAPI.deviceCountUpdated", &value, NULL,
                      NULL);
 }
 
 void DevToolsUIBindings::DevicesUpdated(
     const std::string& source,
     const base::ListValue& targets) {
   CallClientFunction("DevToolsAPI.devicesUpdated", &targets, NULL,
@@ skipping 202 matching lines @@
   if (frontend_loaded_)
     return;
   frontend_loaded_ = true;
 
   // Call delegate first - it seeds importants bit of information.
   delegate_->OnLoadCompleted();
 
   UpdateTheme();
   AddDevToolsExtensionsToClient();
 }