Fix remote trace recording via chrome://inspect?tracing

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 <stddef.h>
 
 #include <memory>
 #include <utility>
@@ skipping 454 matching lines @@
     ~FrontendWebContentsObserver() {
 }
 
 // static
 GURL DevToolsUIBindings::SanitizeFrontendURL(const GURL& url) {
   return ::SanitizeFrontendURL(url, content::kChromeDevToolsScheme,
       chrome::kChromeUIDevToolsHost, SanitizeFrontendPath(url.path()), true);
 }
 
 bool DevToolsUIBindings::IsValidFrontendURL(const GURL& url) {
+  if (url.SchemeIs(content::kChromeUIScheme) &&
+      url.host() == content::kChromeUITracingHost &&
+      !url.has_query() && !url.has_ref()) {
+    return true;
+  }
+
   return SanitizeFrontendURL(url).spec() == url.spec();
 }
 
 void DevToolsUIBindings::FrontendWebContentsObserver::RenderProcessGone(
     base::TerminationStatus status) {
   bool crashed = true;
   switch (status) {
     case base::TERMINATION_STATUS_ABNORMAL_TERMINATION:
     case base::TERMINATION_STATUS_PROCESS_WAS_KILLED:
 #if defined(OS_CHROMEOS)
@@ skipping 90 matching lines @@
   DevToolsUIBindingsList* instances = g_instances.Pointer();
   DevToolsUIBindingsList::iterator it(
       std::find(instances->begin(), instances->end(), this));
   DCHECK(it != instances->end());
   instances->erase(it);
 }
 
 // content::DevToolsFrontendHost::Delegate implementation ---------------------
 void DevToolsUIBindings::HandleMessageFromDevToolsFrontend(
     const std::string& message) {
-  if (!web_contents_->GetURL().SchemeIs(content::kChromeDevToolsScheme))
+  if (!frontend_host_)
     return;
   std::string method;
   base::ListValue empty_params;
   base::ListValue* params = &empty_params;
 
   base::DictionaryValue* dict = NULL;
   std::unique_ptr<base::Value> parsed_message = base::JSONReader::Read(message);
   if (!parsed_message ||
       !parsed_message->GetAsDictionary(&dict) ||
       !dict->GetString(kFrontendHostMethod, &method) ||
       (dict->HasKey(kFrontendHostParams) &&
           !dict->GetList(kFrontendHostParams, &params))) {
     LOG(ERROR) << "Invalid message was sent to embedder: " << message;
     return;
   }
   int id = 0;
   dict->GetInteger(kFrontendHostId, &id);
   embedder_message_dispatcher_->Dispatch(
       base::Bind(&DevToolsUIBindings::SendMessageAck,
                  weak_factory_.GetWeakPtr(),
                  id),
       method,
       params);
 }
 
 // content::DevToolsAgentHostClient implementation --------------------------
 void DevToolsUIBindings::DispatchProtocolMessage(
     content::DevToolsAgentHost* agent_host, const std::string& message) {
   DCHECK(agent_host == agent_host_.get());
-  if (!web_contents_->GetURL().SchemeIs(content::kChromeDevToolsScheme))
+  if (!frontend_host_)
     return;
 
   if (message.length() < kMaxMessageChunkSize) {
     std::string param;
     base::EscapeJSONString(message, true, &param);
     base::string16 javascript =
         base::UTF8ToUTF16("DevToolsAPI.dispatchMessage(" + param + ");");
     web_contents_->GetMainFrame()->ExecuteJavaScript(javascript);
     return;
   }
@@ skipping 95 matching lines @@
 }
 
 void DevToolsUIBindings::AppendToFile(const std::string& url,
                                       const std::string& content) {
   file_helper_->Append(url, content,
                        base::Bind(&DevToolsUIBindings::AppendedTo,
                                   weak_factory_.GetWeakPtr(), url));
 }
 
 void DevToolsUIBindings::RequestFileSystems() {
-  CHECK(web_contents_->GetURL().SchemeIs(content::kChromeDevToolsScheme));
+  CHECK(IsValidFrontendURL(web_contents_->GetURL()) && frontend_host_);
   std::vector<DevToolsFileHelper::FileSystem> file_systems =
       file_helper_->GetFileSystems();
   base::ListValue file_systems_value;
   for (size_t i = 0; i < file_systems.size(); ++i)
     file_systems_value.Append(CreateFileSystemValue(file_systems[i]));
   CallClientFunction("DevToolsAPI.fileSystemsLoaded",
                      &file_systems_value, NULL, NULL);
 }
 
 void DevToolsUIBindings::AddFileSystem(const std::string& file_system_path) {
-  CHECK(web_contents_->GetURL().SchemeIs(content::kChromeDevToolsScheme));
+  CHECK(IsValidFrontendURL(web_contents_->GetURL()) && frontend_host_);
   file_helper_->AddFileSystem(
       file_system_path,
       base::Bind(&DevToolsUIBindings::ShowDevToolsConfirmInfoBar,
                  weak_factory_.GetWeakPtr()));
 }
 
 void DevToolsUIBindings::RemoveFileSystem(const std::string& file_system_path) {
-  CHECK(web_contents_->GetURL().SchemeIs(content::kChromeDevToolsScheme));
+  CHECK(IsValidFrontendURL(web_contents_->GetURL()) && frontend_host_);
   file_helper_->RemoveFileSystem(file_system_path);
 }
 
 void DevToolsUIBindings::UpgradeDraggedFileSystemPermissions(
     const std::string& file_system_url) {
-  CHECK(web_contents_->GetURL().SchemeIs(content::kChromeDevToolsScheme));
+  CHECK(IsValidFrontendURL(web_contents_->GetURL()) && frontend_host_);
   file_helper_->UpgradeDraggedFileSystemPermissions(
       file_system_url,
       base::Bind(&DevToolsUIBindings::ShowDevToolsConfirmInfoBar,
                  weak_factory_.GetWeakPtr()));
 }
 
 void DevToolsUIBindings::IndexPath(int index_request_id,
                                    const std::string& file_system_path) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  CHECK(web_contents_->GetURL().SchemeIs(content::kChromeDevToolsScheme));
+  CHECK(IsValidFrontendURL(web_contents_->GetURL()) && frontend_host_);
   if (!file_helper_->IsFileSystemAdded(file_system_path)) {
     IndexingDone(index_request_id, file_system_path);
     return;
   }
   if (indexing_jobs_.count(index_request_id) != 0)
     return;
   indexing_jobs_[index_request_id] =
       scoped_refptr<DevToolsFileSystemIndexer::FileSystemIndexingJob>(
           file_system_indexer_->IndexPath(
               file_system_path,
@@ skipping 17 matching lines @@
   if (it == indexing_jobs_.end())
     return;
   it->second->Stop();
   indexing_jobs_.erase(it);
 }
 
 void DevToolsUIBindings::SearchInPath(int search_request_id,
                                       const std::string& file_system_path,
                                       const std::string& query) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  CHECK(web_contents_->GetURL().SchemeIs(content::kChromeDevToolsScheme));
+  CHECK(IsValidFrontendURL(web_contents_->GetURL()) && frontend_host_);
   if (!file_helper_->IsFileSystemAdded(file_system_path)) {
     SearchCompleted(search_request_id,
                     file_system_path,
                     std::vector<std::string>());
     return;
   }
   file_system_indexer_->SearchInPath(file_system_path,
                                      query,
                                      Bind(&DevToolsUIBindings::SearchCompleted,
                                           weak_factory_.GetWeakPtr(),
@@ skipping 465 matching lines @@
 }
 
 bool DevToolsUIBindings::IsAttachedTo(content::DevToolsAgentHost* agent_host) {
   return agent_host_.get() == agent_host;
 }
 
 void DevToolsUIBindings::CallClientFunction(const std::string& function_name,
                                             const base::Value* arg1,
                                             const base::Value* arg2,
                                             const base::Value* arg3) {
-  if (!web_contents_->GetURL().SchemeIs(content::kChromeDevToolsScheme))
-    return;
   // If we're not exposing bindings, we shouldn't call functions either.
   if (!frontend_host_)
     return;
   std::string javascript = function_name + "(";
   if (arg1) {
     std::string json;
     base::JSONWriter::Write(*arg1, &json);
     javascript.append(json);
     if (arg2) {
       base::JSONWriter::Write(*arg2, &json);
@@ skipping 35 matching lines @@
 void DevToolsUIBindings::FrontendLoaded() {
   if (frontend_loaded_)
     return;
   frontend_loaded_ = true;
 
   // Call delegate first - it seeds importants bit of information.
   delegate_->OnLoadCompleted();
 
   AddDevToolsExtensionsToClient();
 }