BASELINE: Update Chromium to 86.0.4240.124

Change-Id: Ide0ff151e94cd665ae6521a446995d34a9d1d644
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>

9 files changed, 159 insertions, 45 deletions

diff --git a/chromium/content/browser/tracing/background_tracing_manager_impl.cc b/chromium/content/browser/tracing/background_tracing_manager_impl.cc
index 42225d2d888..1ab8ed8dc13 100644
--- a/chromium/content/browser/tracing/background_tracing_manager_impl.cc
+++ b/chromium/content/browser/tracing/background_tracing_manager_impl.cc
@@ -130,9 +130,15 @@ bool BackgroundTracingManagerImpl::SetActiveScenario(
 #if defined(OS_ANDROID)
   config_impl = BackgroundReachedCodeTracingObserver::GetInstance()
                     .IncludeReachedCodeConfigIfNeeded(std::move(config_impl));
+
+  if (BackgroundReachedCodeTracingObserver::GetInstance()
+          .enabled_in_current_session()) {
+    data_filtering = DataFiltering::ANONYMIZE_DATA;
+    RecordMetric(Metrics::REACHED_CODE_SCENARIO_TRIGGERED);
+  } else
 #endif
-  if (BackgroundStartupTracingObserver::GetInstance()
-          ->enabled_in_current_session()) {
+      if (BackgroundStartupTracingObserver::GetInstance()
+              ->enabled_in_current_session()) {
     // Anonymize data for startup tracing by default. We currently do not
     // support storing the config in preferences for next session.
     data_filtering = DataFiltering::ANONYMIZE_DATA;
diff --git a/chromium/content/browser/tracing/background_tracing_manager_impl.h b/chromium/content/browser/tracing/background_tracing_manager_impl.h
index 3725e2ec2e7..43548a14dcd 100644
--- a/chromium/content/browser/tracing/background_tracing_manager_impl.h
+++ b/chromium/content/browser/tracing/background_tracing_manager_impl.h
@@ -86,6 +86,7 @@ class BackgroundTracingManagerImpl : public BackgroundTracingManager {
     STARTUP_SCENARIO_TRIGGERED = 12,
     LARGE_UPLOAD_WAITING_TO_RETRY = 13,
     SYSTEM_TRIGGERED = 14,
+    REACHED_CODE_SCENARIO_TRIGGERED = 15,
     NUMBER_OF_BACKGROUND_TRACING_METRICS,
   };
   static void RecordMetric(Metrics metric);
diff --git a/chromium/content/browser/tracing/memory_tracing_browsertest.cc b/chromium/content/browser/tracing/memory_tracing_browsertest.cc
index 16488e2ea0d..a31fe5a3896 100644
--- a/chromium/content/browser/tracing/memory_tracing_browsertest.cc
+++ b/chromium/content/browser/tracing/memory_tracing_browsertest.cc
@@ -339,7 +339,7 @@ IN_PROC_BROWSER_TEST_F(SingleProcessMemoryTracingTest, DISABLED_QueuedDumps) {
 
 // Flaky on Mac. crbug.com/809809
 // Failing on Android ASAN. crbug.com/1041392
-#if defined(OS_MACOSX) || (defined(OS_ANDROID) && defined(ADDRESS_SANITIZER))
+#if defined(OS_MAC) || (defined(OS_ANDROID) && defined(ADDRESS_SANITIZER))
 #define MAYBE_BrowserInitiatedDump DISABLED_BrowserInitiatedDump
 #else
 #define MAYBE_BrowserInitiatedDump BrowserInitiatedDump
@@ -350,7 +350,7 @@ IN_PROC_BROWSER_TEST_F(MemoryTracingTest, MAYBE_BrowserInitiatedDump) {
   Navigate(shell());
 
   EXPECT_CALL(*mock_dump_provider_, OnMemoryDump(_,_)).WillOnce(Return(true));
-#if defined(OS_LINUX)
+#if defined(OS_LINUX) || defined(OS_CHROMEOS)
   // TODO(ssid): Test for dump success once the on start tracing done callback
   // is fixed to be called after enable tracing is acked by all processes,
   // crbug.com/709524. The test still tests if dumping does not crash.
diff --git a/chromium/content/browser/tracing/startup_tracing_browsertest.cc b/chromium/content/browser/tracing/startup_tracing_browsertest.cc
index a4f2b52925e..cd0029c3a0b 100644
--- a/chromium/content/browser/tracing/startup_tracing_browsertest.cc
+++ b/chromium/content/browser/tracing/startup_tracing_browsertest.cc
@@ -61,9 +61,10 @@ class CommandlineStartupTracingTest : public ContentBrowserTest {
   DISALLOW_COPY_AND_ASSIGN(CommandlineStartupTracingTest);
 };
 
-// Failing on Android ASAN, Linux TSAN. crbug.com/1041392
+// Failing on Android/Win ASAN, Linux TSAN. crbug.com/1041392
 #if (defined(OS_ANDROID) && defined(ADDRESS_SANITIZER)) || \
-    (defined(OS_LINUX) && defined(THREAD_SANITIZER))
+    (defined(OS_WIN) && defined(ADDRESS_SANITIZER)) ||     \
+    ((defined(OS_LINUX) || defined(OS_CHROMEOS)) && defined(THREAD_SANITIZER))
 #define MAYBE_TestStartupTracing DISABLED_TestStartupTracing
 #else
 #define MAYBE_TestStartupTracing TestStartupTracing
diff --git a/chromium/content/browser/tracing/tracing_controller_impl.cc b/chromium/content/browser/tracing/tracing_controller_impl.cc
index fa4de6a4eb1..cf6efeec179 100644
--- a/chromium/content/browser/tracing/tracing_controller_impl.cc
+++ b/chromium/content/browser/tracing/tracing_controller_impl.cc
@@ -13,6 +13,7 @@
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/cpu.h"
+#include "base/dcheck_is_on.h"
 #include "base/files/file_tracing.h"
 #include "base/logging.h"
 #include "base/run_loop.h"
@@ -40,6 +41,7 @@
 #include "mojo/public/cpp/system/data_pipe.h"
 #include "net/base/network_change_notifier.h"
 #include "services/tracing/public/cpp/perfetto/perfetto_config.h"
+#include "services/tracing/public/cpp/perfetto/perfetto_traced_process.h"
 #include "services/tracing/public/cpp/trace_event_agent.h"
 #include "services/tracing/public/cpp/traced_process_impl.h"
 #include "services/tracing/public/cpp/tracing_features.h"
@@ -188,6 +190,9 @@ TracingControllerImpl::TracingControllerImpl()
           base::BindOnce(&TracingControllerImpl::OnMachineStatisticsLoaded,
                          weak_ptr_factory_.GetWeakPtr()));
 #endif
+
+  tracing::PerfettoTracedProcess::Get()->SetConsumerConnectionFactory(
+      &GetTracingService, base::ThreadTaskRunnerHandle::Get());
 }
 
 TracingControllerImpl::~TracingControllerImpl() = default;
@@ -253,6 +258,10 @@ TracingControllerImpl::GenerateMetadataDict() {
 #endif  // defined(OS_ANDROID)
   metadata_dict->SetInteger("chrome-bitness", 8 * sizeof(uintptr_t));
 
+#if DCHECK_IS_ON()
+  metadata_dict->SetInteger("chrome-dcheck-on", 1);
+#endif
+
   // OS
 #if defined(OS_CHROMEOS)
   metadata_dict->SetString("os-name", "CrOS");
@@ -306,7 +315,7 @@ TracingControllerImpl::GenerateMetadataDict() {
   metadata_dict->SetString("gpu-psver", gpu_info.pixel_shader_version);
   metadata_dict->SetString("gpu-vsver", gpu_info.vertex_shader_version);
 
-#if defined(OS_MACOSX)
+#if defined(OS_MAC)
   metadata_dict->SetString("gpu-glver", gpu_info.gl_version);
 #elif defined(OS_POSIX)
   metadata_dict->SetString("gpu-gl-vendor", gpu_info.gl_vendor);
diff --git a/chromium/content/browser/tracing/tracing_controller_impl_data_endpoint.cc b/chromium/content/browser/tracing/tracing_controller_impl_data_endpoint.cc
index 9bc2eee77af..3535ace7062 100644
--- a/chromium/content/browser/tracing/tracing_controller_impl_data_endpoint.cc
+++ b/chromium/content/browser/tracing/tracing_controller_impl_data_endpoint.cc
@@ -90,14 +90,20 @@ class FileTraceDataEndpoint : public TracingController::TraceDataEndpoint {
 
     // The temporary trace file is produced in the same folder since paths must
     // be on the same volume.
-    file_ = FileToFILE(CreateAndOpenTemporaryFileInDir(file_path_.DirName(),
-                                                       &pending_file_path_),
-                       "w");
-    if (file_ == nullptr) {
-      LOG(ERROR) << "Failed to open " << file_path_.value();
-      return false;
+    base::File temp_file = CreateAndOpenTemporaryFileInDir(file_path_.DirName(),
+                                                           &pending_file_path_);
+    if (temp_file.IsValid()) {
+      file_ = FileToFILE(std::move(temp_file), "w");
+    } else {
+      LOG(WARNING) << "Unable to use temporary file " << pending_file_path_
+                   << ": "
+                   << base::File::ErrorToString(temp_file.error_details());
+      pending_file_path_.clear();
+      file_ = base::OpenFile(file_path_, "w");
+      LOG_IF(ERROR, file_ == nullptr)
+          << "Failed to open " << file_path_.value();
     }
-    return true;
+    return file_ != nullptr;
   }
 
   void CloseOnBlockingThread() {
@@ -106,12 +112,14 @@ class FileTraceDataEndpoint : public TracingController::TraceDataEndpoint {
       file_ = nullptr;
     }
 
-    base::File::Error error;
-    if (!base::ReplaceFile(pending_file_path_, file_path_, &error)) {
-      LOG(ERROR) << "Cannot replace file '" << file_path_
-                 << "' : " << base::File::ErrorToString(error);
-      base::DeleteFile(pending_file_path_, false);
-      return;
+    if (!pending_file_path_.empty()) {
+      base::File::Error error;
+      if (!base::ReplaceFile(pending_file_path_, file_path_, &error)) {
+        LOG(ERROR) << "Cannot replace file '" << file_path_
+                   << "' : " << base::File::ErrorToString(error);
+        base::DeleteFile(pending_file_path_);
+        return;
+      }
     }
 
     GetUIThreadTaskRunner({})->PostTask(
diff --git a/chromium/content/browser/tracing/tracing_ui.cc b/chromium/content/browser/tracing/tracing_ui.cc
index c1b65f1e2c4..2bffb5eb3b0 100644
--- a/chromium/content/browser/tracing/tracing_ui.cc
+++ b/chromium/content/browser/tracing/tracing_ui.cc
@@ -40,9 +40,17 @@
 #include "content/public/browser/web_ui_data_source.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/url_constants.h"
+#include "services/tracing/public/cpp/perfetto/perfetto_config.h"
+#include "services/tracing/public/cpp/perfetto/perfetto_session.h"
+#include "third_party/perfetto/include/perfetto/tracing/tracing.h"
+#include "third_party/perfetto/protos/perfetto/common/trace_stats.gen.h"
 
 namespace content {
 namespace {
+constexpr char kStreamFormat[] = "stream_format";
+constexpr char kStreamFormatProtobuf[] = "protobuf";
+constexpr char kStreamFormatJSON[] = "json";
+perfetto::TracingSession* g_tracing_session = nullptr;
 
 void OnGotCategories(WebUIDataSource::GotDataCallback callback,
                      const std::set<std::string>& categorySet) {
@@ -61,18 +69,31 @@ void OnRecordingEnabledAck(WebUIDataSource::GotDataCallback callback);
 bool BeginRecording(const std::string& data64,
                     WebUIDataSource::GotDataCallback callback) {
   base::trace_event::TraceConfig trace_config("", "");
-  if (!TracingUI::GetTracingOptions(data64, &trace_config))
+  std::string stream_format;
+  if (!TracingUI::GetTracingOptions(data64, trace_config, stream_format))
     return false;
 
+  // TODO(skyostil): Migrate all use cases from TracingController to Perfetto.
+  if (stream_format == kStreamFormatProtobuf) {
+    if (g_tracing_session)
+      delete g_tracing_session;
+    g_tracing_session = perfetto::Tracing::NewTrace().release();
+    g_tracing_session->Setup(tracing::GetDefaultPerfettoConfig(trace_config));
+
+    auto shared_callback = base::MakeRefCounted<
+        base::RefCountedData<WebUIDataSource::GotDataCallback>>(
+        std::move(callback));
+    g_tracing_session->SetOnStartCallback([shared_callback] {
+      OnRecordingEnabledAck(std::move(shared_callback->data));
+    });
+    g_tracing_session->Start();
+    return true;
+  }
   return TracingController::GetInstance()->StartTracing(
       trace_config,
       base::BindOnce(&OnRecordingEnabledAck, std::move(callback)));
 }
 
-void OnRecordingEnabledAck(WebUIDataSource::GotDataCallback callback) {
-  std::move(callback).Run(base::MakeRefCounted<base::RefCountedString>());
-}
-
 void OnTraceBufferUsageResult(WebUIDataSource::GotDataCallback callback,
                               float percent_full,
                               size_t approximate_event_count) {
@@ -80,6 +101,45 @@ void OnTraceBufferUsageResult(WebUIDataSource::GotDataCallback callback,
   std::move(callback).Run(base::RefCountedString::TakeString(&str));
 }
 
+bool GetTraceBufferUsage(WebUIDataSource::GotDataCallback callback) {
+  if (g_tracing_session) {
+    // |callback| is move-only, so in order to pass it through a copied lambda
+    // we need to temporarily move it on the heap.
+    auto shared_callback = base::MakeRefCounted<
+        base::RefCountedData<WebUIDataSource::GotDataCallback>>(
+        std::move(callback));
+    g_tracing_session->GetTraceStats(
+        [shared_callback](
+            perfetto::TracingSession::GetTraceStatsCallbackArgs args) {
+          std::string usage;
+          perfetto::protos::gen::TraceStats trace_stats;
+          if (args.success &&
+              trace_stats.ParseFromArray(args.trace_stats_data.data(),
+                                         args.trace_stats_data.size())) {
+            double percent_full = tracing::GetTraceBufferUsage(trace_stats);
+            usage = base::NumberToString(percent_full);
+          }
+          std::move(shared_callback->data)
+              .Run(base::RefCountedString::TakeString(&usage));
+        });
+    return true;
+  }
+
+  return TracingController::GetInstance()->GetTraceBufferUsage(
+      base::BindOnce(OnTraceBufferUsageResult, std::move(callback)));
+}
+
+void ReadProtobufTraceData(
+    scoped_refptr<TracingController::TraceDataEndpoint> endpoint,
+    perfetto::TracingSession::ReadTraceCallbackArgs args) {
+  if (args.size) {
+    auto data_string = std::make_unique<std::string>(args.data, args.size);
+    endpoint->ReceiveTraceChunk(std::move(data_string));
+  }
+  if (!args.has_more)
+    endpoint->ReceivedTraceFinalContents();
+}
+
 void TracingCallbackWrapperBase64(WebUIDataSource::GotDataCallback callback,
                                   std::unique_ptr<std::string> data) {
   base::RefCountedString* data_base64 = new base::RefCountedString();
@@ -87,6 +147,38 @@ void TracingCallbackWrapperBase64(WebUIDataSource::GotDataCallback callback,
   std::move(callback).Run(data_base64);
 }
 
+bool EndRecording(WebUIDataSource::GotDataCallback callback) {
+  if (!TracingController::GetInstance()->IsTracing() && !g_tracing_session)
+    return false;
+
+  scoped_refptr<TracingController::TraceDataEndpoint> data_endpoint =
+      TracingControllerImpl::CreateCompressedStringEndpoint(
+          TracingControllerImpl::CreateCallbackEndpoint(base::BindOnce(
+              TracingCallbackWrapperBase64, std::move(callback))),
+          false /* compress_with_background_priority */);
+
+  if (g_tracing_session) {
+    perfetto::TracingSession* session = g_tracing_session;
+    g_tracing_session = nullptr;
+    session->SetOnStopCallback([session, data_endpoint] {
+      session->ReadTrace(
+          [session, data_endpoint](
+              perfetto::TracingSession::ReadTraceCallbackArgs args) {
+            ReadProtobufTraceData(data_endpoint, args);
+            if (!args.has_more)
+              delete session;
+          });
+    });
+    session->Stop();
+    return true;
+  }
+  return TracingController::GetInstance()->StopTracing(data_endpoint);
+}
+
+void OnRecordingEnabledAck(WebUIDataSource::GotDataCallback callback) {
+  std::move(callback).Run(base::MakeRefCounted<base::RefCountedString>());
+}
+
 bool OnBeginJSONRequest(const std::string& path,
                         WebUIDataSource::GotDataCallback callback) {
   if (path == "json/categories") {
@@ -101,18 +193,10 @@ bool OnBeginJSONRequest(const std::string& path,
     return BeginRecording(data, std::move(callback));
   }
   if (path == "json/get_buffer_percent_full") {
-    return TracingController::GetInstance()->GetTraceBufferUsage(
-        base::BindOnce(OnTraceBufferUsageResult, std::move(callback)));
+    return GetTraceBufferUsage(std::move(callback));
   }
   if (path == "json/end_recording_compressed") {
-    if (!TracingController::GetInstance()->IsTracing())
-      return false;
-    scoped_refptr<TracingController::TraceDataEndpoint> data_endpoint =
-        TracingControllerImpl::CreateCompressedStringEndpoint(
-            TracingControllerImpl::CreateCallbackEndpoint(base::BindOnce(
-                TracingCallbackWrapperBase64, std::move(callback))),
-            false /* compress_with_background_priority */);
-    return TracingController::GetInstance()->StopTracing(data_endpoint);
+    return EndRecording(std::move(callback));
   }
 
   LOG(ERROR) << "Unhandled request to " << path;
@@ -156,6 +240,7 @@ TracingUI::TracingUI(WebUI* web_ui)
       web_ui->GetWebContents()->GetBrowserContext();
 
   WebUIDataSource* source = WebUIDataSource::Create(kChromeUITracingHost);
+  source->DisableTrustedTypesCSP();
   source->UseStringsJs();
   source->SetDefaultResource(IDR_TRACING_HTML);
   source->AddResourcePath("tracing.js", IDR_TRACING_JS);
@@ -167,9 +252,9 @@ TracingUI::TracingUI(WebUI* web_ui)
 TracingUI::~TracingUI() = default;
 
 // static
-bool TracingUI::GetTracingOptions(
-    const std::string& data64,
-    base::trace_event::TraceConfig* trace_config) {
+bool TracingUI::GetTracingOptions(const std::string& data64,
+                                  base::trace_event::TraceConfig& trace_config,
+                                  std::string& out_stream_format) {
   std::string data;
   if (!base::Base64Decode(data64, &data)) {
     LOG(ERROR) << "Options were not base64 encoded.";
@@ -188,13 +273,14 @@ bool TracingUI::GetTracingOptions(
     return false;
   }
 
-  if (!trace_config) {
-    LOG(ERROR) << "trace_config can't be passed as NULL";
-    return false;
+  if (options->HasKey(kStreamFormat)) {
+    options->GetString(kStreamFormat, &out_stream_format);
+  } else {
+    out_stream_format = kStreamFormatJSON;
   }
 
   // New style options dictionary.
-  *trace_config = base::trace_event::TraceConfig(*options);
+  trace_config = base::trace_event::TraceConfig(*options);
   return true;
 }
 
diff --git a/chromium/content/browser/tracing/tracing_ui.h b/chromium/content/browser/tracing/tracing_ui.h
index 2bb89e71269..33dbb84118f 100644
--- a/chromium/content/browser/tracing/tracing_ui.h
+++ b/chromium/content/browser/tracing/tracing_ui.h
@@ -32,8 +32,8 @@ class CONTENT_EXPORT TracingUI : public WebUIController {
 
   // Public for testing.
   static bool GetTracingOptions(const std::string& data64,
-                                base::trace_event::TraceConfig* trace_config);
-
+                                base::trace_event::TraceConfig& trace_config,
+                                std::string& out_stream_format);
 
  private:
   std::unique_ptr<TracingDelegate> delegate_;
diff --git a/chromium/content/browser/tracing/tracing_ui_unittest.cc b/chromium/content/browser/tracing/tracing_ui_unittest.cc
index 431949fec9c..51f63a44a25 100644
--- a/chromium/content/browser/tracing/tracing_ui_unittest.cc
+++ b/chromium/content/browser/tracing/tracing_ui_unittest.cc
@@ -34,6 +34,7 @@ std::string GetConfig() {
   dict->SetList("excluded_categories", std::move(excluded));
   dict->SetString("record_mode", "record-continuously");
   dict->SetBoolean("enable_systrace", true);
+  dict->SetString("stream_format", "protobuf");
 
   std::unique_ptr<base::DictionaryValue> memory_config(
       new base::DictionaryValue());
@@ -56,12 +57,14 @@ std::string GetConfig() {
 
 TEST_F(TracingUITest, ConfigParsing) {
   base::trace_event::TraceConfig config;
-  ASSERT_TRUE(TracingUI::GetTracingOptions(GetConfig(), &config));
+  std::string stream_format;
+  ASSERT_TRUE(TracingUI::GetTracingOptions(GetConfig(), config, stream_format));
   EXPECT_EQ(config.GetTraceRecordMode(),
             base::trace_event::RECORD_CONTINUOUSLY);
   std::string expected(base::trace_event::MemoryDumpManager::kTraceCategory);
   expected += ",-filter2";
   EXPECT_EQ(config.ToCategoryFilterString(), expected);
+  EXPECT_EQ(stream_format, "protobuf");
   EXPECT_TRUE(config.IsSystraceEnabled());
 
   ASSERT_EQ(config.memory_dump_config().triggers.size(), 1u);