DevTools: response writers need to post to the UI while sending into streams.

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 61 matching lines @@
 
 static const char kDevToolsActionTakenHistogram[] = "DevTools.ActionTaken";
 static const int kDevToolsActionTakenBoundary = 100;
 static const char kDevToolsPanelShownHistogram[] = "DevTools.PanelShown";
 static const int kDevToolsPanelShownBoundary = 20;
 
 // This constant should be in sync with
 // the constant at shell_devtools_frontend.cc.
 const size_t kMaxMessageChunkSize = IPC::Channel::kMaximumMessageSize / 4;
 
-typedef std::vector<DevToolsUIBindings*> DevToolsUIBindingsList;
+using DevToolsUIBindingsList = std::vector<DevToolsUIBindings*>;
 base::LazyInstance<DevToolsUIBindingsList>::Leaky g_instances =
     LAZY_INSTANCE_INITIALIZER;
 
+using StreamOwners = std::map<int, DevToolsUIBindings*>;
+base::LazyInstance<StreamOwners>::Leaky g_stream_owners =
+    LAZY_INSTANCE_INITIALIZER;
+
 std::string SkColorToRGBAString(SkColor color) {
   // We avoid StringPrintf because it will use locale specific formatters for
   // the double (e.g. ',' instead of '.' in German).
   return "rgba(" + base::IntToString(SkColorGetR(color)) + "," +
       base::IntToString(SkColorGetG(color)) + "," +
       base::IntToString(SkColorGetB(color)) + "," +
       base::DoubleToString(SkColorGetA(color) / 255.0) + ")";
 }
 
 base::DictionaryValue* CreateFileSystemValue(
@@ skipping 139 matching lines @@
 }
 
 InfoBarService* DefaultBindingsDelegate::GetInfoBarService() {
   return InfoBarService::FromWebContents(web_contents_);
 }
 
 // ResponseWriter -------------------------------------------------------------
 
 class ResponseWriter : public net::URLFetcherResponseWriter {
  public:
-  ResponseWriter(DevToolsUIBindings* bindings, int stream_id);
+  explicit ResponseWriter(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 stream_id)
+    : stream_id_(stream_id) {
 }
 
 ResponseWriter::~ResponseWriter() {
 }
 
 int ResponseWriter::Initialize(const net::CompletionCallback& callback) {
   return net::OK;
 }
 
+static void WriteResponseOnUI(int stream_id, const std::string& chunk) {
+  auto it = g_stream_owners.Get().find(stream_id);
+  if (it != g_stream_owners.Get().end()) {
+    base::FundamentalValue id(stream_id);
+    base::StringValue value(chunk);
+    it->second->CallClientFunction(
+        "DevToolsAPI.streamWrite", &id, &value, nullptr);
+  }
+}
+
 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);
+  content::BrowserThread::PostTask(
+      content::BrowserThread::UI, FROM_HERE,
+      base::Bind(&WriteResponseOnUI, stream_id_,
+                 std::string(buffer->data(), num_bytes)));
   return num_bytes;
 }
 
+static void FinishResponseOnUI(int stream_id) {
+  auto it = g_stream_owners.Get().find(stream_id);
+  if (it != g_stream_owners.Get().end()) {
+    base::FundamentalValue id(stream_id);
+    it->second->CallClientFunction(
+        "DevToolsAPI.streamFinish", &id, nullptr, nullptr);
+  }
+}
+
 int ResponseWriter::Finish(const net::CompletionCallback& callback) {
-  base::FundamentalValue id(stream_id_);
-  bindings_->CallClientFunction(
-      "DevToolsAPI.streamFinish", &id, nullptr, nullptr);
+  content::BrowserThread::PostTask(
+      content::BrowserThread::UI, FROM_HERE,
+      base::Bind(&FinishResponseOnUI, stream_id_));
   return net::OK;
 }
 
 }  // namespace
 
 // DevToolsUIBindings::FrontendWebContentsObserver ----------------------------
 
 class DevToolsUIBindings::FrontendWebContentsObserver
     : public content::WebContentsObserver {
  public:
@@ skipping 136 matching lines @@
       DevToolsEmbedderMessageDispatcher::CreateForDevToolsFrontend(this));
 
   frontend_host_.reset(content::DevToolsFrontendHost::Create(
       web_contents_->GetMainFrame(), this));
 }
 
 DevToolsUIBindings::~DevToolsUIBindings() {
   for (const auto& pair : pending_requests_)
     delete pair.first;
 
+  for (auto it = g_stream_owners.Get().begin();
+       it !=  g_stream_owners.Get().end(); ) {
+    if (it->second == this)
+      g_stream_owners.Get().erase(it);
+    else
+      ++it;
+  }
+
   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 119 matching lines @@
                                              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);
     return;
   }
 
+  g_stream_owners.Get()[stream_id] = this;

[dgozman, 2015/02/28 16:06:13]

This will make streams from different DevTools clash.

+
   net::URLFetcher* fetcher =
       net::URLFetcher::Create(gurl, net::URLFetcher::GET, this);
-  pending_requests_[fetcher] = request_id;
+  pending_requests_[fetcher] = std::make_pair(request_id, stream_id);
   fetcher->SetRequestContext(profile_->GetRequestContext());
   fetcher->SetExtraRequestHeaders(headers);
   fetcher->SaveResponseWithWriter(scoped_ptr<net::URLFetcherResponseWriter>(
-      new ResponseWriter(this, stream_id)));
+      new ResponseWriter(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,
@@ skipping 195 matching lines @@
   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);
+  int request_id = it->second.first;
+  int stream_id = it->second.second;
+  SendMessageAck(request_id, &response);
+  g_stream_owners.Get().erase(stream_id);
   pending_requests_.erase(it);
   delete source;
 }
 
 void DevToolsUIBindings::DeviceCountChanged(int count) {
   base::FundamentalValue value(count);
   CallClientFunction("DevToolsAPI.deviceCountUpdated", &value, NULL,
                      NULL);
 }
 
@@ skipping 206 matching lines @@
   if (frontend_loaded_)
     return;
   frontend_loaded_ = true;
 
   // Call delegate first - it seeds importants bit of information.
   delegate_->OnLoadCompleted();
 
   UpdateTheme();
   AddDevToolsExtensionsToClient();
 }