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/base/io_buffer.h"
+#include "net/base/net_errors.h"
+#include "net/http/http_response_headers.h"
+#include "net/url_request/url_fetcher.h"
+#include "net/url_request/url_fetcher_response_writer.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 166 matching lines @@
 }
 
 void DefaultBindingsDelegate::InspectedContentsClosing() {
   web_contents_->GetRenderViewHost()->ClosePage();
 }
 
 InfoBarService* DefaultBindingsDelegate::GetInfoBarService() {
   return InfoBarService::FromWebContents(web_contents_);
 }
 
+// ResponseWriter -------------------------------------------------------------
+
+class ResponseWriter : public net::URLFetcherResponseWriter {
+ public:
+  ResponseWriter(DevToolsUIBindings* bindings, int stream_id);
+  ~ResponseWriter() override;
+
+  // URLFetcherResponseWriter overrides:
+  int Initialize(const net::CompletionCallback& callback) override;
+  int Write(net::IOBuffer* buffer,
+            int num_bytes,
+            const net::CompletionCallback& callback) override;
+  int Finish(const net::CompletionCallback& callback) override;
+
+ private:
+  DevToolsUIBindings* bindings_;
+  int stream_id_;
+
+  DISALLOW_COPY_AND_ASSIGN(ResponseWriter);
+};
+
+ResponseWriter::ResponseWriter(DevToolsUIBindings* bindings,
+                               int stream_id)
+    : bindings_(bindings),
+      stream_id_(stream_id) {
+}
+
+ResponseWriter::~ResponseWriter() {
+}
+
+int ResponseWriter::Initialize(const net::CompletionCallback& callback) {
+  return net::OK;
+}
+
+int ResponseWriter::Write(net::IOBuffer* buffer,
+                          int num_bytes,
+                          const net::CompletionCallback& callback) {
+  base::FundamentalValue id(stream_id_);
+  base::StringValue chunk(std::string(buffer->data(), num_bytes));
+  bindings_->CallClientFunction(
+      "DevToolsAPI.streamWrite", &id, &chunk, nullptr);
+  return num_bytes;
+}
+
+int ResponseWriter::Finish(const net::CompletionCallback& callback) {
+  base::FundamentalValue id(stream_id_);
+  bindings_->CallClientFunction(
+      "DevToolsAPI.streamFinish", &id, nullptr, nullptr);
+  return net::OK;
+}
+
 }  // namespace
 
 // DevToolsUIBindings::FrontendWebContentsObserver ----------------------------
 
 class DevToolsUIBindings::FrontendWebContentsObserver
     : public content::WebContentsObserver {
  public:
   explicit FrontendWebContentsObserver(DevToolsUIBindings* ui_bindings);
   ~FrontendWebContentsObserver() override;
 
@@ skipping 130 matching lines @@
           ThemeServiceFactory::GetForProfile(profile_)));
 
   embedder_message_dispatcher_.reset(
       DevToolsEmbedderMessageDispatcher::CreateForDevToolsFrontend(this));
 
   frontend_host_.reset(content::DevToolsFrontendHost::Create(
       web_contents_->GetMainFrame(), this));
 }
 
 DevToolsUIBindings::~DevToolsUIBindings() {
+  for (const auto& pair : pending_requests_)
+    delete pair.first;
+
   if (agent_host_.get())
     agent_host_->DetachClient();
 
   for (IndexingJobsMap::const_iterator jobs_it(indexing_jobs_.begin());
        jobs_it != indexing_jobs_.end(); ++jobs_it) {
     jobs_it->second->Stop();
   }
   indexing_jobs_.clear();
   SetDeviceCountUpdatesEnabled(0, false);
   SetDevicesUpdatesEnabled(0, false);
@@ skipping 63 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,
+                                             int stream_id) {
+  GURL gurl(url);
+  if (!gurl.is_valid()) {
+    base::DictionaryValue response;
+    response.SetInteger("statusCode", 404);
+    SendMessageAck(request_id, &response);

[dgozman, 2015/02/27 20:23:01]

DevToolsAPI.streamFinish before ack?

[pfeldman, 2015/02/27 20:37:42]

Lets make client responsible for this.

+    return;
+  }
+
+  net::URLFetcher* fetcher =
+      net::URLFetcher::Create(gurl, net::URLFetcher::GET, this);
+  pending_requests_[fetcher] = request_id;
+  fetcher->SetRequestContext(profile_->GetRequestContext());
+  fetcher->SetExtraRequestHeaders(headers);
+  fetcher->SaveResponseWithWriter(scoped_ptr<net::URLFetcherResponseWriter>(
+      new ResponseWriter(this, stream_id)));
+  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());
+
+  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);
+
+  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);
+  delete source;
+}
+
 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();
 }