BASELINE: Update Chromium to 70.0.3538.78

Change-Id: Ie634710bf039e26c1957f4ae45e101bd4c434ae7
Reviewed-by: Michael Brüning <michael.bruning@qt.io>

12 files changed, 72 insertions, 39 deletions

diff --git a/chromium/gin/arguments.cc b/chromium/gin/arguments.cc
index b492fae6d57..46552a5022a 100644
--- a/chromium/gin/arguments.cc
+++ b/chromium/gin/arguments.cc
@@ -44,11 +44,11 @@ std::vector<v8::Local<v8::Value>> Arguments::GetAll() const {
   return result;
 }
 
-v8::Local<v8::Context> Arguments::GetHolderCreationContext() {
+v8::Local<v8::Context> Arguments::GetHolderCreationContext() const {
   return info_->Holder()->CreationContext();
 }
 
-std::string V8TypeAsString(v8::Local<v8::Value> value) {
+std::string V8TypeAsString(v8::Isolate* isolate, v8::Local<v8::Value> value) {
   if (value.IsEmpty())
     return "<empty handle>";
   if (value->IsUndefined())
@@ -56,7 +56,7 @@ std::string V8TypeAsString(v8::Local<v8::Value> value) {
   if (value->IsNull())
     return "null";
   std::string result;
-  if (!ConvertFromV8(NULL, value, &result))
+  if (!ConvertFromV8(isolate, value, &result))
     return std::string();
   return result;
 }
@@ -67,7 +67,7 @@ void Arguments::ThrowError() const {
 
   return ThrowTypeError(base::StringPrintf(
       "Error processing argument at index %d, conversion failure from %s",
-      next_ - 1, V8TypeAsString((*info_)[next_ - 1]).c_str()));
+      next_ - 1, V8TypeAsString(isolate_, (*info_)[next_ - 1]).c_str()));
 }
 
 void Arguments::ThrowTypeError(const std::string& message) const {
diff --git a/chromium/gin/arguments.h b/chromium/gin/arguments.h
index c0a7bc2171d..e793706f71c 100644
--- a/chromium/gin/arguments.h
+++ b/chromium/gin/arguments.h
@@ -75,7 +75,7 @@ class GIN_EXPORT Arguments {
   }
 
   // Returns the creation context of the Holder.
-  v8::Local<v8::Context> GetHolderCreationContext();
+  v8::Local<v8::Context> GetHolderCreationContext() const;
 
   // Always check the return value whether the handle is empty before
   // dereferencing the handle.
diff --git a/chromium/gin/converter.cc b/chromium/gin/converter.cc
index 42fcd59adb9..975a5c8b9e5 100644
--- a/chromium/gin/converter.cc
+++ b/chromium/gin/converter.cc
@@ -141,9 +141,10 @@ bool Converter<std::string>::FromV8(Isolate* isolate,
   if (!val->IsString())
     return false;
   Local<String> str = Local<String>::Cast(val);
-  int length = str->Utf8Length();
+  int length = str->Utf8Length(isolate);
   out->resize(length);
-  str->WriteUtf8(&(*out)[0], length, NULL, String::NO_NULL_TERMINATION);
+  str->WriteUtf8(isolate, &(*out)[0], length, NULL,
+                 String::NO_NULL_TERMINATION);
   return true;
 }
 
@@ -217,11 +218,11 @@ v8::Local<v8::String> StringToSymbol(v8::Isolate* isolate,
       .ToLocalChecked();
 }
 
-std::string V8ToString(v8::Local<v8::Value> value) {
+std::string V8ToString(v8::Isolate* isolate, v8::Local<v8::Value> value) {
   if (value.IsEmpty())
     return std::string();
   std::string result;
-  if (!ConvertFromV8(NULL, value, &result))
+  if (!ConvertFromV8(isolate, value, &result))
     return std::string();
   return result;
 }
diff --git a/chromium/gin/converter.h b/chromium/gin/converter.h
index 19ec02a3e08..a501714a5e8 100644
--- a/chromium/gin/converter.h
+++ b/chromium/gin/converter.h
@@ -255,10 +255,12 @@ GIN_EXPORT v8::Local<v8::String> StringToSymbol(v8::Isolate* isolate,
 template<typename T>
 bool ConvertFromV8(v8::Isolate* isolate, v8::Local<v8::Value> input,
                    T* result) {
+  DCHECK(isolate);
   return Converter<T>::FromV8(isolate, input, result);
 }
 
-GIN_EXPORT std::string V8ToString(v8::Local<v8::Value> value);
+GIN_EXPORT std::string V8ToString(v8::Isolate* isolate,
+                                  v8::Local<v8::Value> value);
 
 }  // namespace gin
 
diff --git a/chromium/gin/isolate_holder.cc b/chromium/gin/isolate_holder.cc
index e3a23cf30e4..4491b392412 100644
--- a/chromium/gin/isolate_holder.cc
+++ b/chromium/gin/isolate_holder.cc
@@ -31,23 +31,29 @@ const intptr_t* g_reference_table = nullptr;
 }  // namespace
 
 IsolateHolder::IsolateHolder(
-    scoped_refptr<base::SingleThreadTaskRunner> task_runner)
-    : IsolateHolder(std::move(task_runner), AccessMode::kSingleThread) {}
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner,
+    IsolateType isolate_type)
+    : IsolateHolder(std::move(task_runner),
+                    AccessMode::kSingleThread,
+                    isolate_type) {}
 
 IsolateHolder::IsolateHolder(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
-    AccessMode access_mode)
+    AccessMode access_mode,
+    IsolateType isolate_type)
     : IsolateHolder(std::move(task_runner),
                     access_mode,
                     kAllowAtomicsWait,
+                    isolate_type,
                     IsolateCreationMode::kNormal) {}
 
 IsolateHolder::IsolateHolder(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     AccessMode access_mode,
     AllowAtomicsWaitMode atomics_wait_mode,
+    IsolateType isolate_type,
     IsolateCreationMode isolate_creation_mode)
-    : access_mode_(access_mode) {
+    : access_mode_(access_mode), isolate_type_(isolate_type) {
   DCHECK(task_runner);
   DCHECK(task_runner->BelongsToCurrentThread());
 
diff --git a/chromium/gin/public/isolate_holder.h b/chromium/gin/public/isolate_holder.h
index a70ad1ce51a..6945a60181c 100644
--- a/chromium/gin/public/isolate_holder.h
+++ b/chromium/gin/public/isolate_holder.h
@@ -58,14 +58,28 @@ class GIN_EXPORT IsolateHolder {
     kCreateSnapshot,
   };
 
-  explicit IsolateHolder(
-      scoped_refptr<base::SingleThreadTaskRunner> task_runner);
+  // Isolate type used for UMA/UKM reporting:
+  // - kBlinkMainThread: the main isolate of Blink.
+  // - kBlinkWorkerThread: the isolate of a Blink worker.
+  // - kTest: used only in tests.
+  // - kUtility: the isolate of PDFium and ProxyResolver.
+  enum class IsolateType {
+    kBlinkMainThread,
+    kBlinkWorkerThread,
+    kTest,
+    kUtility
+  };
+
   IsolateHolder(scoped_refptr<base::SingleThreadTaskRunner> task_runner,
-                AccessMode access_mode);
+                IsolateType isolate_type);
+  IsolateHolder(scoped_refptr<base::SingleThreadTaskRunner> task_runner,
+                AccessMode access_mode,
+                IsolateType isolate_type);
   IsolateHolder(
       scoped_refptr<base::SingleThreadTaskRunner> task_runner,
       AccessMode access_mode,
       AllowAtomicsWaitMode atomics_wait_mode,
+      IsolateType isolate_type,
       IsolateCreationMode isolate_creation_mode = IsolateCreationMode::kNormal);
   ~IsolateHolder();
 
@@ -90,6 +104,8 @@ class GIN_EXPORT IsolateHolder {
   // This method returns if v8::Locker is needed to access isolate.
   AccessMode access_mode() const { return access_mode_; }
 
+  IsolateType isolate_type() const { return isolate_type_; }
+
   v8::SnapshotCreator* snapshot_creator() const {
     return snapshot_creator_.get();
   }
@@ -111,6 +127,7 @@ class GIN_EXPORT IsolateHolder {
   std::unique_ptr<PerIsolateData> isolate_data_;
   std::unique_ptr<V8IsolateMemoryDumpProvider> isolate_memory_dump_provider_;
   AccessMode access_mode_;
+  IsolateType isolate_type_;
 
   DISALLOW_COPY_AND_ASSIGN(IsolateHolder);
 };
diff --git a/chromium/gin/shell/gin_main.cc b/chromium/gin/shell/gin_main.cc
index d5b769dfff3..eb0c68612bd 100644
--- a/chromium/gin/shell/gin_main.cc
+++ b/chromium/gin/shell/gin_main.cc
@@ -14,7 +14,7 @@
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
-#include "base/task_scheduler/task_scheduler.h"
+#include "base/task/task_scheduler/task_scheduler.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "gin/array_buffer.h"
 #include "gin/modules/console.h"
@@ -84,7 +84,9 @@ int main(int argc, char** argv) {
     gin::IsolateHolder::Initialize(gin::IsolateHolder::kStrictMode,
                                    gin::IsolateHolder::kStableV8Extras,
                                    gin::ArrayBufferAllocator::SharedInstance());
-    gin::IsolateHolder instance(base::ThreadTaskRunnerHandle::Get());
+    gin::IsolateHolder instance(
+        base::ThreadTaskRunnerHandle::Get(),
+        gin::IsolateHolder::IsolateType::kBlinkMainThread);
 
     gin::GinShellRunnerDelegate delegate;
     gin::ShellRunner runner(&delegate, instance.isolate());
diff --git a/chromium/gin/shell_runner_unittest.cc b/chromium/gin/shell_runner_unittest.cc
index 02e6835abcf..1a5ad6bc46d 100644
--- a/chromium/gin/shell_runner_unittest.cc
+++ b/chromium/gin/shell_runner_unittest.cc
@@ -36,7 +36,8 @@ TEST(RunnerTest, Run) {
   gin::IsolateHolder::Initialize(gin::IsolateHolder::kStrictMode,
                                  gin::IsolateHolder::kStableV8Extras,
                                  gin::ArrayBufferAllocator::SharedInstance());
-  gin::IsolateHolder instance(base::ThreadTaskRunnerHandle::Get());
+  gin::IsolateHolder instance(base::ThreadTaskRunnerHandle::Get(),
+                              gin::IsolateHolder::IsolateType::kTest);
 
   ShellRunnerDelegate delegate;
   Isolate* isolate = instance.isolate();
diff --git a/chromium/gin/try_catch.cc b/chromium/gin/try_catch.cc
index 24512bc2218..821719294cf 100644
--- a/chromium/gin/try_catch.cc
+++ b/chromium/gin/try_catch.cc
@@ -38,8 +38,8 @@ std::string TryCatch::GetStackTrace() {
 
   std::stringstream ss;
   v8::Local<v8::Message> message = try_catch_.Message();
-  ss << V8ToString(message->Get()) << std::endl
-     << V8ToString(GetSourceLine(isolate_, message)) << std::endl;
+  ss << V8ToString(isolate_, message->Get()) << std::endl
+     << V8ToString(isolate_, GetSourceLine(isolate_, message)) << std::endl;
 
   v8::Local<v8::StackTrace> trace = message->GetStackTrace();
   if (trace.IsEmpty())
@@ -47,12 +47,10 @@ std::string TryCatch::GetStackTrace() {
 
   int len = trace->GetFrameCount();
   for (int i = 0; i < len; ++i) {
-    v8::Local<v8::StackFrame> frame = trace->GetFrame(i);
-    ss << V8ToString(frame->GetScriptName()) << ":"
-       << frame->GetLineNumber() << ":"
-       << frame->GetColumn() << ": "
-       << V8ToString(frame->GetFunctionName())
-       << std::endl;
+    v8::Local<v8::StackFrame> frame = trace->GetFrame(isolate_, i);
+    ss << V8ToString(isolate_, frame->GetScriptName()) << ":"
+       << frame->GetLineNumber() << ":" << frame->GetColumn() << ": "
+       << V8ToString(isolate_, frame->GetFunctionName()) << std::endl;
   }
   return ss.str();
 }
diff --git a/chromium/gin/v8_initializer.cc b/chromium/gin/v8_initializer.cc
index be2b9149e44..cf51b27dd99 100644
--- a/chromium/gin/v8_initializer.cc
+++ b/chromium/gin/v8_initializer.cc
@@ -243,10 +243,10 @@ void V8Initializer::Initialize(IsolateHolder::ScriptMode mode,
 
   v8::V8::InitializePlatform(V8Platform::Get());
 
-  if (base::FeatureList::IsEnabled(features::kV8OptimizeJavascript)) {
-    static const char optimize[] = "--opt";
-    v8::V8::SetFlagsFromString(optimize, sizeof(optimize) - 1);
-  } else {
+  if (!base::FeatureList::IsEnabled(features::kV8OptimizeJavascript)) {
+    // We avoid explicitly passing --opt if kV8OptimizeJavascript is enabled
+    // since it is the default, and doing so would override flags passed
+    // explicitly, e.g., via --js-flags=--no-opt.
     static const char no_optimize[] = "--no-opt";
     v8::V8::SetFlagsFromString(no_optimize, sizeof(no_optimize) - 1);
   }
diff --git a/chromium/gin/v8_platform.cc b/chromium/gin/v8_platform.cc
index 8e885b9b208..84555603f58 100644
--- a/chromium/gin/v8_platform.cc
+++ b/chromium/gin/v8_platform.cc
@@ -16,9 +16,9 @@
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "base/sys_info.h"
-#include "base/task_scheduler/post_task.h"
-#include "base/task_scheduler/task_scheduler.h"
-#include "base/task_scheduler/task_traits.h"
+#include "base/task/post_task.h"
+#include "base/task/task_scheduler/task_scheduler.h"
+#include "base/task/task_traits.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "gin/per_isolate_data.h"
@@ -119,7 +119,11 @@ class TimeClamper {
   TimeClamper() : secret_(base::RandUint64()) {}
 
   double ClampTimeResolution(double time_seconds) const {
-    DCHECK_GE(time_seconds, 0);
+    bool was_negative = false;
+    if (time_seconds < 0) {
+      was_negative = true;
+      time_seconds = -time_seconds;
+    }
     // For each clamped time interval, compute a pseudorandom transition
     // threshold. The reported time will either be the start of that interval or
     // the next one depending on which side of the threshold |time_seconds| is.
@@ -128,7 +132,9 @@ class TimeClamper {
     double tick_threshold = ThresholdFor(clamped_time);
 
     if (time_seconds >= tick_threshold)
-      return (interval + 1) * kResolutionSeconds;
+      clamped_time = (interval + 1) * kResolutionSeconds;
+    if (was_negative)
+      clamped_time = -clamped_time;
     return clamped_time;
   }
 
diff --git a/chromium/gin/wrappable_unittest.cc b/chromium/gin/wrappable_unittest.cc
index 716c89edfc3..701991b4483 100644
--- a/chromium/gin/wrappable_unittest.cc
+++ b/chromium/gin/wrappable_unittest.cc
@@ -209,7 +209,7 @@ TEST_F(WrappableTest, MethodInvocationErrorsOnUnnamedObject) {
     func->Call(v8::Undefined(isolate), arraysize(argv), argv);
     if (!try_catch.HasCaught())
       return std::string();
-    return V8ToString(try_catch.Message()->Get());
+    return V8ToString(isolate, try_catch.Message()->Get());
   };
 
   EXPECT_EQ(std::string(), get_error(member_method, v8_object));
@@ -264,7 +264,7 @@ TEST_F(WrappableTest, MethodInvocationErrorsOnNamedObject) {
     func->Call(v8::Undefined(isolate), arraysize(argv), argv);
     if (!try_catch.HasCaught())
       return std::string();
-    return V8ToString(try_catch.Message()->Get());
+    return V8ToString(isolate, try_catch.Message()->Get());
   };
 
   EXPECT_EQ(std::string(), get_error(member_method, v8_object));