BASELINE: Update Chromium to 85.0.4183.14085-based

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

32 files changed, 453 insertions, 206 deletions

diff --git a/chromium/content/browser/devtools/protocol/audits_handler.cc b/chromium/content/browser/devtools/protocol/audits_handler.cc
index 9f32e63e2f8..b6baeeac78e 100644
--- a/chromium/content/browser/devtools/protocol/audits_handler.cc
+++ b/chromium/content/browser/devtools/protocol/audits_handler.cc
@@ -5,6 +5,9 @@
 #include "content/browser/devtools/protocol/audits_handler.h"
 
 #include "content/browser/devtools/devtools_agent_host_impl.h"
+#include "content/browser/devtools/devtools_issue_storage.h"
+#include "content/browser/devtools/render_frame_devtools_agent_host.h"
+#include "content/browser/frame_host/frame_tree_node.h"
 
 namespace content {
 namespace protocol {
@@ -19,6 +22,11 @@ std::vector<AuditsHandler*> AuditsHandler::ForAgentHost(
   return host->HandlersByName<AuditsHandler>(Audits::Metainfo::domainName);
 }
 
+void AuditsHandler::SetRenderer(int process_host_id,
+                                RenderFrameHostImpl* frame_host) {
+  host_ = frame_host;
+}
+
 void AuditsHandler::Wire(UberDispatcher* dispatcher) {
   frontend_ = std::make_unique<Audits::Frontend>(dispatcher->channel());
   Audits::Dispatcher::wire(dispatcher, this);
@@ -29,10 +37,57 @@ DispatchResponse AuditsHandler::Disable() {
   return Response::FallThrough();
 }
 
+namespace {
+
+void SendStoredIssuesForFrameToAgent(RenderFrameHostImpl* rfh,
+                                     protocol::AuditsHandler* handler) {
+  // Check the storage first. No need to do any work in case its empty.
+  WebContents* web_contents = WebContents::FromRenderFrameHost(rfh);
+  DevToolsIssueStorage* issue_storage =
+      DevToolsIssueStorage::FromWebContents(web_contents);
+  if (!issue_storage)
+    return;
+
+  FrameTreeNode* local_root = rfh->frame_tree_node();
+
+  std::vector<int> frame_tree_node_ids;
+  for (FrameTreeNode* node : rfh->frame_tree()->SubtreeNodes(local_root)) {
+    // For each child we find the child's local root. Should the child's local
+    // root match |local_root|, the provided |AuditsHandler| is responsible and
+    // we collect the devtools_frame_token.
+    if (local_root == GetFrameTreeNodeAncestor(node)) {
+      frame_tree_node_ids.push_back(node->frame_tree_node_id());
+    }
+  }
+
+  base::flat_set<int> frame_ids_set(frame_tree_node_ids);
+  auto issues = issue_storage->FilterIssuesBy(std::move(frame_ids_set));
+  for (auto* const issue : issues) {
+    handler->OnIssueAdded(issue);
+  }
+}
+
+}  // namespace
+
 DispatchResponse AuditsHandler::Enable() {
+  if (enabled_) {
+    return Response::FallThrough();
+  }
+
   enabled_ = true;
+  if (host_) {
+    SendStoredIssuesForFrameToAgent(host_, this);
+  }
+
   return Response::FallThrough();
 }
 
+void AuditsHandler::OnIssueAdded(
+    const protocol::Audits::InspectorIssue* issue) {
+  if (enabled_) {
+    frontend_->IssueAdded(issue->clone());
+  }
+}
+
 }  // namespace protocol
 }  // namespace content
diff --git a/chromium/content/browser/devtools/protocol/audits_handler.h b/chromium/content/browser/devtools/protocol/audits_handler.h
index 1d00247954c..f80587abdf7 100644
--- a/chromium/content/browser/devtools/protocol/audits_handler.h
+++ b/chromium/content/browser/devtools/protocol/audits_handler.h
@@ -8,6 +8,7 @@
 #include "base/macros.h"
 #include "content/browser/devtools/protocol/audits.h"
 #include "content/browser/devtools/protocol/devtools_domain_handler.h"
+#include "content/browser/frame_host/render_frame_host_impl.h"
 #include "mojo/public/cpp/bindings/remote.h"
 
 namespace content {
@@ -25,15 +26,20 @@ class AuditsHandler final : public DevToolsDomainHandler,
   static std::vector<AuditsHandler*> ForAgentHost(DevToolsAgentHostImpl* host);
 
   // DevToolsDomainHandler implementation.
+  void SetRenderer(int process_host_id,
+                   RenderFrameHostImpl* frame_host) override;
   void Wire(UberDispatcher* dispatcher) override;
 
   // Audits::Backend implementation.
   DispatchResponse Disable() override;
   DispatchResponse Enable() override;
 
+  void OnIssueAdded(const protocol::Audits::InspectorIssue* issue);
+
  private:
   std::unique_ptr<Audits::Frontend> frontend_;
   bool enabled_ = false;
+  RenderFrameHostImpl* host_;
 
   DISALLOW_COPY_AND_ASSIGN(AuditsHandler);
 };
diff --git a/chromium/content/browser/devtools/protocol/browser_handler.cc b/chromium/content/browser/devtools/protocol/browser_handler.cc
index fd8287531b8..d446d4f44de 100644
--- a/chromium/content/browser/devtools/protocol/browser_handler.cc
+++ b/chromium/content/browser/devtools/protocol/browser_handler.cc
@@ -35,7 +35,7 @@ BrowserHandler::BrowserHandler(bool allow_set_download_behavior)
     : DevToolsDomainHandler(Browser::Metainfo::domainName),
       allow_set_download_behavior_(allow_set_download_behavior) {}
 
-BrowserHandler::~BrowserHandler() {}
+BrowserHandler::~BrowserHandler() = default;
 
 Response BrowserHandler::Disable() {
   // TODO: this leaks context ids for all contexts with overridden permissions.
diff --git a/chromium/content/browser/devtools/protocol/devtools_domain_handler.cc b/chromium/content/browser/devtools/protocol/devtools_domain_handler.cc
index e89a12e0aa3..802bb71f364 100644
--- a/chromium/content/browser/devtools/protocol/devtools_domain_handler.cc
+++ b/chromium/content/browser/devtools/protocol/devtools_domain_handler.cc
@@ -14,8 +14,7 @@ DevToolsDomainHandler::DevToolsDomainHandler(const std::string& name)
     : name_(name) {
 }
 
-DevToolsDomainHandler::~DevToolsDomainHandler() {
-}
+DevToolsDomainHandler::~DevToolsDomainHandler() = default;
 
 void DevToolsDomainHandler::SetRenderer(int process_host_id,
                                         RenderFrameHostImpl* frame_host) {}
diff --git a/chromium/content/browser/devtools/protocol/devtools_download_manager_delegate.cc b/chromium/content/browser/devtools/protocol/devtools_download_manager_delegate.cc
index a33e174eb94..d751a29a847 100644
--- a/chromium/content/browser/devtools/protocol/devtools_download_manager_delegate.cc
+++ b/chromium/content/browser/devtools/protocol/devtools_download_manager_delegate.cc
@@ -6,7 +6,6 @@
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
-#include "base/task/post_task.h"
 #include "base/task/thread_pool.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_task_traits.h"
@@ -81,6 +80,7 @@ bool DevToolsDownloadManagerDelegate::DetermineDownloadTarget(
         empty_path, download::DownloadItem::TARGET_DISPOSITION_OVERWRITE,
         download::DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
         download::DownloadItem::MixedContentStatus::UNKNOWN, empty_path,
+        base::nullopt /*download_schedule*/,
         download::DOWNLOAD_INTERRUPT_REASON_USER_CANCELED);
     return true;
   }
@@ -147,8 +147,8 @@ void DevToolsDownloadManagerDelegate::GenerateFilename(
     base::CreateDirectory(suggested_directory);
 
   base::FilePath suggested_path(suggested_directory.Append(generated_name));
-  base::PostTask(FROM_HERE, {content::BrowserThread::UI},
-                 base::BindOnce(std::move(callback), suggested_path));
+  content::GetUIThreadTaskRunner({})->PostTask(
+      FROM_HERE, base::BindOnce(std::move(callback), suggested_path));
 }
 
 void DevToolsDownloadManagerDelegate::OnDownloadPathGenerated(
@@ -162,6 +162,7 @@ void DevToolsDownloadManagerDelegate::OnDownloadPathGenerated(
       download::DOWNLOAD_DANGER_TYPE_MAYBE_DANGEROUS_CONTENT,
       download::DownloadItem::MixedContentStatus::UNKNOWN,
       suggested_path.AddExtension(FILE_PATH_LITERAL(".crdownload")),
+      base::nullopt /*download_schedule*/,
       download::DOWNLOAD_INTERRUPT_REASON_NONE);
 }
 
diff --git a/chromium/content/browser/devtools/protocol/devtools_mhtml_helper.cc b/chromium/content/browser/devtools/protocol/devtools_mhtml_helper.cc
index 102d27af5a1..fb44f934f42 100644
--- a/chromium/content/browser/devtools/protocol/devtools_mhtml_helper.cc
+++ b/chromium/content/browser/devtools/protocol/devtools_mhtml_helper.cc
@@ -5,7 +5,6 @@
 #include "content/browser/devtools/protocol/devtools_mhtml_helper.h"
 
 #include "base/bind.h"
-#include "base/task/post_task.h"
 #include "base/task/thread_pool.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/public/browser/browser_task_traits.h"
@@ -30,8 +29,8 @@ DevToolsMHTMLHelper::DevToolsMHTMLHelper(
 
 DevToolsMHTMLHelper::~DevToolsMHTMLHelper() {
   if (mhtml_file_.get()) {
-    base::PostTask(
-        FROM_HERE, {BrowserThread::IO},
+    GetIOThreadTaskRunner({})->PostTask(
+        FROM_HERE,
         base::BindOnce(&ClearFileReferenceOnIOThread, std::move(mhtml_file_)));
   }
 }
@@ -58,8 +57,8 @@ void DevToolsMHTMLHelper::CreateTemporaryFile() {
     ReportFailure("Unable to create temporary file");
     return;
   }
-  base::PostTask(
-      FROM_HERE, {BrowserThread::IO},
+  GetIOThreadTaskRunner({})->PostTask(
+      FROM_HERE,
       base::BindOnce(&DevToolsMHTMLHelper::TemporaryFileCreatedOnIO, this));
 }
 
@@ -82,8 +81,8 @@ void DevToolsMHTMLHelper::TemporaryFileCreatedOnIO() {
            base::TaskShutdownBehavior::BLOCK_SHUTDOWN})
           .get());
 
-  base::PostTask(
-      FROM_HERE, {BrowserThread::UI},
+  GetUIThreadTaskRunner({})->PostTask(
+      FROM_HERE,
       base::BindOnce(&DevToolsMHTMLHelper::TemporaryFileCreatedOnUI, this));
 }
 
@@ -135,8 +134,8 @@ void DevToolsMHTMLHelper::ReadMHTML() {
 
 void DevToolsMHTMLHelper::ReportFailure(const std::string& message) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
-    base::PostTask(
-        FROM_HERE, {BrowserThread::UI},
+    GetUIThreadTaskRunner({})->PostTask(
+        FROM_HERE,
         base::BindOnce(&DevToolsMHTMLHelper::ReportFailure, this, message));
     return;
   }
@@ -149,8 +148,8 @@ void DevToolsMHTMLHelper::ReportFailure(const std::string& message) {
 void DevToolsMHTMLHelper::ReportSuccess(
     std::unique_ptr<std::string> mhtml_snapshot) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
-    base::PostTask(FROM_HERE, {BrowserThread::UI},
-                   base::BindOnce(&DevToolsMHTMLHelper::ReportSuccess, this,
+    GetUIThreadTaskRunner({})->PostTask(
+        FROM_HERE, base::BindOnce(&DevToolsMHTMLHelper::ReportSuccess, this,
                                   std::move(mhtml_snapshot)));
     return;
   }
diff --git a/chromium/content/browser/devtools/protocol/devtools_protocol_browsertest.cc b/chromium/content/browser/devtools/protocol/devtools_protocol_browsertest.cc
index c2ae1f64f0b..049c5506f75 100644
--- a/chromium/content/browser/devtools/protocol/devtools_protocol_browsertest.cc
+++ b/chromium/content/browser/devtools/protocol/devtools_protocol_browsertest.cc
@@ -16,6 +16,7 @@
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "base/system/sys_info.h"
+#include "base/test/scoped_feature_list.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "components/download/public/common/download_file_factory.h"
@@ -26,6 +27,7 @@
 #include "content/browser/download/download_manager_impl.h"
 #include "content/browser/frame_host/navigator.h"
 #include "content/browser/renderer_host/render_widget_host_view_base.h"
+#include "content/browser/service_worker/embedded_worker_test_helper.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/download_manager.h"
@@ -1995,6 +1997,72 @@ IN_PROC_BROWSER_TEST_F(DevToolsProtocolTest, CertificateExplanations) {
             explanation_cert->CalculateChainFingerprint256());
 }
 
+class DevToolsProtocolBackForwardCacheTest : public DevToolsProtocolTest {
+ public:
+  DevToolsProtocolBackForwardCacheTest() {
+    feature_list_.InitWithFeaturesAndParameters(
+        {{features::kBackForwardCache,
+          {{"TimeToLiveInBackForwardCacheInSeconds", "3600"}}}},
+        {});
+  }
+  ~DevToolsProtocolBackForwardCacheTest() override = default;
+
+  std::string Evaluate(std::string script, base::Location location) {
+    std::unique_ptr<base::DictionaryValue> params(new base::DictionaryValue());
+    params->SetString("expression", script);
+    SendCommand("Runtime.evaluate", std::move(params), true);
+    base::Value* result_value;
+    EXPECT_TRUE(result_->Get("result.value", &result_value));
+    DCHECK(result_value->is_string())
+        << "Valued to evaluate " << script << " from " << location.ToString();
+    return result_value->GetString();
+  }
+
+ private:
+  base::test::ScopedFeatureList feature_list_;
+};
+
+// This test checks that the DevTools continue to work when the page is stored
+// in and restored from back-forward cache. In particular:
+// - that the session continues to be attached and the navigations are handled
+// correctly.
+// - when the old page is stored in the cache, the messages are still handled by
+// the new page.
+// - when the page is restored from the cache, it continues to handle protocol
+// messages.
+IN_PROC_BROWSER_TEST_F(DevToolsProtocolBackForwardCacheTest, Basic) {
+  ASSERT_TRUE(embedded_test_server()->Start());
+  GURL url_a(embedded_test_server()->GetURL("a.com", "/title1.html"));
+  GURL url_b(embedded_test_server()->GetURL("b.com", "/title1.html"));
+
+  // 1) Navigate to A and inject some state.
+  EXPECT_TRUE(NavigateToURL(shell(), url_a));
+  EXPECT_TRUE(ExecJs(shell(), "var state = 'page1'"));
+
+  // 2) Attach DevTools session.
+  Attach();
+
+  // 3) Extract the state via the DevTools protocol.
+  EXPECT_EQ("page1", Evaluate("state", FROM_HERE));
+
+  // 3) Navigate to B and inject some different state.
+  EXPECT_TRUE(NavigateToURL(shell(), url_b));
+  EXPECT_TRUE(ExecJs(shell(), "var state = 'page2'"));
+
+  // 4) Ensure that the DevTools protocol commands are handled by the new page
+  // (even though the old page is alive and is stored in the back-forward
+  // cache).
+  EXPECT_EQ("page2", Evaluate("state", FROM_HERE));
+
+  // 5) Go back.
+  shell()->web_contents()->GetController().GoBack();
+  EXPECT_TRUE(WaitForLoadStop(shell()->web_contents()));
+
+  // 6) Ensure that the page has been restored from the cache and responds to
+  // the DevTools commands.
+  EXPECT_EQ("page1", Evaluate("state", FROM_HERE));
+}
+
 // Download tests are flaky on Android: https://crbug.com/7546
 #if !defined(OS_ANDROID)
 namespace {
diff --git a/chromium/content/browser/devtools/protocol/dom_handler.cc b/chromium/content/browser/devtools/protocol/dom_handler.cc
index dba7b3a115c..ccc1376efe7 100644
--- a/chromium/content/browser/devtools/protocol/dom_handler.cc
+++ b/chromium/content/browser/devtools/protocol/dom_handler.cc
@@ -17,8 +17,7 @@ DOMHandler::DOMHandler(bool allow_file_access)
       host_(nullptr),
       allow_file_access_(allow_file_access) {}
 
-DOMHandler::~DOMHandler() {
-}
+DOMHandler::~DOMHandler() = default;
 
 void DOMHandler::Wire(UberDispatcher* dispatcher) {
   DOM::Dispatcher::wire(dispatcher, this);
diff --git a/chromium/content/browser/devtools/protocol/emulation_handler.cc b/chromium/content/browser/devtools/protocol/emulation_handler.cc
index 470cfa7bd30..0528b6bf0e0 100644
--- a/chromium/content/browser/devtools/protocol/emulation_handler.cc
+++ b/chromium/content/browser/devtools/protocol/emulation_handler.cc
@@ -74,8 +74,7 @@ EmulationHandler::EmulationHandler()
       focus_emulation_enabled_(false),
       host_(nullptr) {}
 
-EmulationHandler::~EmulationHandler() {
-}
+EmulationHandler::~EmulationHandler() = default;
 
 // static
 std::vector<EmulationHandler*> EmulationHandler::ForAgentHost(
@@ -467,13 +466,25 @@ void EmulationHandler::UpdateDeviceEmulationState() {
   // this is tricky since we'd have to track the DevTools message id with the
   // WidgetMsg and acknowledgment, as well as plump the acknowledgment back to
   // the EmulationHandler somehow. Mojo callbacks should make this much simpler.
+  UpdateDeviceEmulationStateForHost(host_->GetRenderWidgetHost());
+
+  // Update portals inside this page.
+  for (auto* web_contents : GetWebContents()->GetWebContentsAndAllInner()) {
+    if (web_contents->IsPortal()) {
+      UpdateDeviceEmulationStateForHost(
+          web_contents->GetMainFrame()->GetRenderWidgetHost());
+    }
+  }
+}
+
+void EmulationHandler::UpdateDeviceEmulationStateForHost(
+    RenderWidgetHostImpl* render_widget_host) {
   if (device_emulation_enabled_) {
-    host_->GetRenderWidgetHost()->Send(new WidgetMsg_EnableDeviceEmulation(
-        host_->GetRenderWidgetHost()->GetRoutingID(),
-        device_emulation_params_));
+    render_widget_host->Send(new WidgetMsg_EnableDeviceEmulation(
+        render_widget_host->GetRoutingID(), device_emulation_params_));
   } else {
-    host_->GetRenderWidgetHost()->Send(new WidgetMsg_DisableDeviceEmulation(
-        host_->GetRenderWidgetHost()->GetRoutingID()));
+    render_widget_host->Send(new WidgetMsg_DisableDeviceEmulation(
+        render_widget_host->GetRoutingID()));
   }
 }
 
diff --git a/chromium/content/browser/devtools/protocol/emulation_handler.h b/chromium/content/browser/devtools/protocol/emulation_handler.h
index 0f1e96586ec..1fc66de4be3 100644
--- a/chromium/content/browser/devtools/protocol/emulation_handler.h
+++ b/chromium/content/browser/devtools/protocol/emulation_handler.h
@@ -19,6 +19,7 @@ namespace content {
 
 class DevToolsAgentHostImpl;
 class RenderFrameHostImpl;
+class RenderWidgetHostImpl;
 class WebContentsImpl;
 
 namespace protocol {
@@ -86,6 +87,8 @@ class EmulationHandler : public DevToolsDomainHandler,
   WebContentsImpl* GetWebContents();
   void UpdateTouchEventEmulationState();
   void UpdateDeviceEmulationState();
+  void UpdateDeviceEmulationStateForHost(
+      RenderWidgetHostImpl* render_widget_host);
 
   bool touch_emulation_enabled_;
   std::string touch_emulation_configuration_;
diff --git a/chromium/content/browser/devtools/protocol/input_handler.cc b/chromium/content/browser/devtools/protocol/input_handler.cc
index 2bbaea8f2dd..53d74a4ce3c 100644
--- a/chromium/content/browser/devtools/protocol/input_handler.cc
+++ b/chromium/content/browser/devtools/protocol/input_handler.cc
@@ -374,6 +374,7 @@ class InputHandler::InputInjector
   }
 
   void InjectKeyboardEvent(const NativeWebKeyboardEvent& keyboard_event,
+                           Maybe<Array<std::string>> commands,
                            std::unique_ptr<DispatchKeyEventCallback> callback) {
     if (!widget_host_) {
       callback->sendFailure(Response::InternalError());
@@ -383,7 +384,15 @@ class InputHandler::InputInjector
     widget_host_->Focus();
     input_queued_ = false;
     pending_key_callbacks_.push_back(std::move(callback));
-    widget_host_->ForwardKeyboardEvent(keyboard_event);
+    ui::LatencyInfo latency;
+    std::vector<blink::mojom::EditCommandPtr> edit_commands;
+    if (commands.isJust()) {
+      for (const std::string& command : *commands.fromJust())
+        edit_commands.push_back(blink::mojom::EditCommand::New(command, ""));
+    }
+
+    widget_host_->ForwardKeyboardEventWithCommands(keyboard_event, latency,
+                                                   std::move(edit_commands));
     if (!input_queued_) {
       pending_key_callbacks_.back()->sendSuccess();
       pending_key_callbacks_.pop_back();
@@ -468,8 +477,7 @@ InputHandler::InputHandler()
       page_scale_factor_(1.0),
       last_id_(0) {}
 
-InputHandler::~InputHandler() {
-}
+InputHandler::~InputHandler() = default;
 
 // static
 std::vector<InputHandler*> InputHandler::ForAgentHost(
@@ -538,6 +546,7 @@ void InputHandler::DispatchKeyEvent(
     Maybe<bool> is_keypad,
     Maybe<bool> is_system_key,
     Maybe<int> location,
+    Maybe<Array<std::string>> commands,
     std::unique_ptr<DispatchKeyEventCallback> callback) {
   blink::WebInputEvent::Type web_event_type;
 
@@ -610,7 +619,8 @@ void InputHandler::DispatchKeyEvent(
   else
     event.skip_in_browser = true;
 
-  EnsureInjector(widget_host)->InjectKeyboardEvent(event, std::move(callback));
+  EnsureInjector(widget_host)
+      ->InjectKeyboardEvent(event, std::move(commands), std::move(callback));
 }
 
 void InputHandler::InsertText(const std::string& text,
diff --git a/chromium/content/browser/devtools/protocol/input_handler.h b/chromium/content/browser/devtools/protocol/input_handler.h
index 8abc50f6227..23d569995f2 100644
--- a/chromium/content/browser/devtools/protocol/input_handler.h
+++ b/chromium/content/browser/devtools/protocol/input_handler.h
@@ -7,8 +7,9 @@
 
 #include <memory>
 #include <set>
+#include <string>
+#include <vector>
 
-#include "base/containers/circular_deque.h"
 #include "base/containers/flat_map.h"
 #include "base/containers/flat_set.h"
 #include "base/containers/unique_ptr_adapters.h"
@@ -60,6 +61,7 @@ class InputHandler : public DevToolsDomainHandler, public Input::Backend {
       Maybe<bool> is_keypad,
       Maybe<bool> is_system_key,
       Maybe<int> location,
+      Maybe<Array<std::string>> commands,
       std::unique_ptr<DispatchKeyEventCallback> callback) override;
 
   void InsertText(const std::string& text,
diff --git a/chromium/content/browser/devtools/protocol/inspector_handler.cc b/chromium/content/browser/devtools/protocol/inspector_handler.cc
index fe3d7fa6ec5..a50014571da 100644
--- a/chromium/content/browser/devtools/protocol/inspector_handler.cc
+++ b/chromium/content/browser/devtools/protocol/inspector_handler.cc
@@ -11,12 +11,9 @@ namespace content {
 namespace protocol {
 
 InspectorHandler::InspectorHandler()
-    : DevToolsDomainHandler(Inspector::Metainfo::domainName),
-      host_(nullptr) {
-}
+    : DevToolsDomainHandler(Inspector::Metainfo::domainName) {}
 
-InspectorHandler::~InspectorHandler() {
-}
+InspectorHandler::~InspectorHandler() = default;
 
 // static
 std::vector<InspectorHandler*> InspectorHandler::ForAgentHost(
@@ -36,10 +33,14 @@ void InspectorHandler::SetRenderer(int process_host_id,
 }
 
 void InspectorHandler::TargetCrashed() {
+  target_crashed_ = true;
   frontend_->TargetCrashed();
 }
 
 void InspectorHandler::TargetReloadedAfterCrash() {
+  // Only send the event if targetCrashed was previously sent in this session.
+  if (!target_crashed_)
+    return;
   frontend_->TargetReloadedAfterCrash();
 }
 
@@ -49,7 +50,7 @@ void InspectorHandler::TargetDetached(const std::string& reason) {
 
 Response InspectorHandler::Enable() {
   if (host_ && !host_->IsRenderFrameLive())
-    frontend_->TargetCrashed();
+    TargetCrashed();
   return Response::Success();
 }
 
diff --git a/chromium/content/browser/devtools/protocol/inspector_handler.h b/chromium/content/browser/devtools/protocol/inspector_handler.h
index 19ba4e86034..13858677c06 100644
--- a/chromium/content/browser/devtools/protocol/inspector_handler.h
+++ b/chromium/content/browser/devtools/protocol/inspector_handler.h
@@ -38,7 +38,8 @@ class InspectorHandler : public DevToolsDomainHandler,
 
  private:
   std::unique_ptr<Inspector::Frontend> frontend_;
-  RenderFrameHostImpl* host_;
+  RenderFrameHostImpl* host_ = nullptr;
+  bool target_crashed_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(InspectorHandler);
 };
diff --git a/chromium/content/browser/devtools/protocol/io_handler.cc b/chromium/content/browser/devtools/protocol/io_handler.cc
index 8ec26b2ed7a..c49d8dad673 100644
--- a/chromium/content/browser/devtools/protocol/io_handler.cc
+++ b/chromium/content/browser/devtools/protocol/io_handler.cc
@@ -29,7 +29,7 @@ IOHandler::IOHandler(DevToolsIOContext* io_context)
       browser_context_(nullptr),
       storage_partition_(nullptr) {}
 
-IOHandler::~IOHandler() {}
+IOHandler::~IOHandler() = default;
 
 void IOHandler::Wire(UberDispatcher* dispatcher) {
   frontend_.reset(new IO::Frontend(dispatcher->channel()));
diff --git a/chromium/content/browser/devtools/protocol/log_handler.cc b/chromium/content/browser/devtools/protocol/log_handler.cc
index 4fca4ddf95d..67dc75c7b93 100644
--- a/chromium/content/browser/devtools/protocol/log_handler.cc
+++ b/chromium/content/browser/devtools/protocol/log_handler.cc
@@ -32,11 +32,11 @@ DispatchResponse LogHandler::Enable() {
   return Response::FallThrough();
 }
 
-void LogHandler::EntryAdded(std::unique_ptr<Log::LogEntry> entry) {
+void LogHandler::EntryAdded(Log::LogEntry* entry) {
   if (!enabled_) {
     return;
   }
-  frontend_->EntryAdded(std::move(entry));
+  frontend_->EntryAdded(entry->clone());
 }
 
 }  // namespace protocol
diff --git a/chromium/content/browser/devtools/protocol/log_handler.h b/chromium/content/browser/devtools/protocol/log_handler.h
index 45b54550e1b..96a1d712734 100644
--- a/chromium/content/browser/devtools/protocol/log_handler.h
+++ b/chromium/content/browser/devtools/protocol/log_handler.h
@@ -31,7 +31,7 @@ class LogHandler final : public DevToolsDomainHandler, public Log::Backend {
   DispatchResponse Disable() override;
   DispatchResponse Enable() override;
 
-  void EntryAdded(std::unique_ptr<Log::LogEntry> entry);
+  void EntryAdded(Log::LogEntry* entry);
 
  private:
   std::unique_ptr<Log::Frontend> frontend_;
diff --git a/chromium/content/browser/devtools/protocol/memory_handler.cc b/chromium/content/browser/devtools/protocol/memory_handler.cc
index bdec2689ec8..af4525c8192 100644
--- a/chromium/content/browser/devtools/protocol/memory_handler.cc
+++ b/chromium/content/browser/devtools/protocol/memory_handler.cc
@@ -21,7 +21,7 @@ MemoryHandler::MemoryHandler()
     : DevToolsDomainHandler(Memory::Metainfo::domainName),
       process_host_id_(ChildProcessHost::kInvalidUniqueID) {}
 
-MemoryHandler::~MemoryHandler() {}
+MemoryHandler::~MemoryHandler() = default;
 
 void MemoryHandler::Wire(UberDispatcher* dispatcher) {
   Memory::Dispatcher::wire(dispatcher, this);
diff --git a/chromium/content/browser/devtools/protocol/network_handler.cc b/chromium/content/browser/devtools/protocol/network_handler.cc
index 4b900c1f83a..a8bcb0eb483 100644
--- a/chromium/content/browser/devtools/protocol/network_handler.cc
+++ b/chromium/content/browser/devtools/protocol/network_handler.cc
@@ -64,6 +64,7 @@
 #include "net/cert/x509_certificate.h"
 #include "net/cert/x509_util.h"
 #include "net/cookies/canonical_cookie.h"
+#include "net/cookies/cookie_inclusion_status.h"
 #include "net/cookies/cookie_util.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_status_code.h"
@@ -181,10 +182,10 @@ class CookieRetrieverNetworkService
   CookieRetrieverNetworkService(std::unique_ptr<GetCookiesCallback> callback)
       : callback_(std::move(callback)) {}
 
-  void GotCookies(const net::CookieStatusList& cookies,
-                  const net::CookieStatusList& excluded_cookies) {
-    for (const auto& cookie_with_status : cookies) {
-      const net::CanonicalCookie& cookie = cookie_with_status.cookie;
+  void GotCookies(const net::CookieAccessResultList& cookies,
+                  const net::CookieAccessResultList& excluded_cookies) {
+    for (const auto& cookie_with_access_result : cookies) {
+      const net::CanonicalCookie& cookie = cookie_with_access_result.cookie;
       std::string key = base::StringPrintf(
           "%s::%s::%s::%d", cookie.Name().c_str(), cookie.Domain().c_str(),
           cookie.Path().c_str(), cookie.IsSecure());
@@ -440,6 +441,11 @@ std::unique_ptr<Network::ResourceTiming> GetTiming(
                            load_timing.request_start))
       .SetWorkerStart(-1)
       .SetWorkerReady(-1)
+      .SetWorkerFetchStart(timeDelta(load_timing.service_worker_fetch_start,
+                                     load_timing.request_start))
+      .SetWorkerRespondWithSettled(
+          timeDelta(load_timing.service_worker_respond_with_settled,
+                    load_timing.request_start))
       .SetSendStart(
           timeDelta(load_timing.send_start, load_timing.request_start))
       .SetSendEnd(timeDelta(load_timing.send_end, load_timing.request_start))
@@ -543,65 +549,64 @@ std::unique_ptr<Array<Network::SignedExchangeError>> BuildSignedExchangeErrors(
 }
 
 std::unique_ptr<Array<Network::SetCookieBlockedReason>>
-GetProtocolBlockedSetCookieReason(
-    net::CanonicalCookie::CookieInclusionStatus status) {
+GetProtocolBlockedSetCookieReason(net::CookieInclusionStatus status) {
   std::unique_ptr<Array<Network::SetCookieBlockedReason>> blockedReasons =
       std::make_unique<Array<Network::SetCookieBlockedReason>>();
   if (status.HasExclusionReason(
-          net::CanonicalCookie::CookieInclusionStatus::EXCLUDE_SECURE_ONLY)) {
+          net::CookieInclusionStatus::EXCLUDE_SECURE_ONLY)) {
     blockedReasons->push_back(Network::SetCookieBlockedReasonEnum::SecureOnly);
   }
-  if (status.HasExclusionReason(net::CanonicalCookie::CookieInclusionStatus::
-                                    EXCLUDE_SAMESITE_STRICT)) {
+  if (status.HasExclusionReason(
+          net::CookieInclusionStatus::EXCLUDE_SAMESITE_STRICT)) {
     blockedReasons->push_back(
         Network::SetCookieBlockedReasonEnum::SameSiteStrict);
   }
   if (status.HasExclusionReason(
-          net::CanonicalCookie::CookieInclusionStatus::EXCLUDE_SAMESITE_LAX)) {
+          net::CookieInclusionStatus::EXCLUDE_SAMESITE_LAX)) {
     blockedReasons->push_back(Network::SetCookieBlockedReasonEnum::SameSiteLax);
   }
   if (status.HasExclusionReason(
-          net::CanonicalCookie::CookieInclusionStatus::
+          net::CookieInclusionStatus::
               EXCLUDE_SAMESITE_UNSPECIFIED_TREATED_AS_LAX)) {
     blockedReasons->push_back(
         Network::SetCookieBlockedReasonEnum::SameSiteUnspecifiedTreatedAsLax);
   }
-  if (status.HasExclusionReason(net::CanonicalCookie::CookieInclusionStatus::
-                                    EXCLUDE_SAMESITE_NONE_INSECURE)) {
+  if (status.HasExclusionReason(
+          net::CookieInclusionStatus::EXCLUDE_SAMESITE_NONE_INSECURE)) {
     blockedReasons->push_back(
         Network::SetCookieBlockedReasonEnum::SameSiteNoneInsecure);
   }
-  if (status.HasExclusionReason(net::CanonicalCookie::CookieInclusionStatus::
-                                    EXCLUDE_USER_PREFERENCES)) {
+  if (status.HasExclusionReason(
+          net::CookieInclusionStatus::EXCLUDE_USER_PREFERENCES)) {
     blockedReasons->push_back(
         Network::SetCookieBlockedReasonEnum::UserPreferences);
   }
-  if (status.HasExclusionReason(net::CanonicalCookie::CookieInclusionStatus::
-                                    EXCLUDE_FAILURE_TO_STORE)) {
+  if (status.HasExclusionReason(
+          net::CookieInclusionStatus::EXCLUDE_FAILURE_TO_STORE)) {
     blockedReasons->push_back(Network::SetCookieBlockedReasonEnum::SyntaxError);
   }
-  if (status.HasExclusionReason(net::CanonicalCookie::CookieInclusionStatus::
-                                    EXCLUDE_NONCOOKIEABLE_SCHEME)) {
+  if (status.HasExclusionReason(
+          net::CookieInclusionStatus::EXCLUDE_NONCOOKIEABLE_SCHEME)) {
     blockedReasons->push_back(
         Network::SetCookieBlockedReasonEnum::SchemeNotSupported);
   }
-  if (status.HasExclusionReason(net::CanonicalCookie::CookieInclusionStatus::
-                                    EXCLUDE_OVERWRITE_SECURE)) {
+  if (status.HasExclusionReason(
+          net::CookieInclusionStatus::EXCLUDE_OVERWRITE_SECURE)) {
     blockedReasons->push_back(
         Network::SetCookieBlockedReasonEnum::OverwriteSecure);
   }
-  if (status.HasExclusionReason(net::CanonicalCookie::CookieInclusionStatus::
-                                    EXCLUDE_INVALID_DOMAIN)) {
+  if (status.HasExclusionReason(
+          net::CookieInclusionStatus::EXCLUDE_INVALID_DOMAIN)) {
     blockedReasons->push_back(
         Network::SetCookieBlockedReasonEnum::InvalidDomain);
   }
-  if (status.HasExclusionReason(net::CanonicalCookie::CookieInclusionStatus::
-                                    EXCLUDE_INVALID_PREFIX)) {
+  if (status.HasExclusionReason(
+          net::CookieInclusionStatus::EXCLUDE_INVALID_PREFIX)) {
     blockedReasons->push_back(
         Network::SetCookieBlockedReasonEnum::InvalidPrefix);
   }
   if (status.HasExclusionReason(
-          net::CanonicalCookie::CookieInclusionStatus::EXCLUDE_UNKNOWN_ERROR)) {
+          net::CookieInclusionStatus::EXCLUDE_UNKNOWN_ERROR)) {
     blockedReasons->push_back(
         Network::SetCookieBlockedReasonEnum::UnknownError);
   }
@@ -610,49 +615,48 @@ GetProtocolBlockedSetCookieReason(
 }
 
 std::unique_ptr<Array<Network::CookieBlockedReason>>
-GetProtocolBlockedCookieReason(
-    net::CanonicalCookie::CookieInclusionStatus status) {
+GetProtocolBlockedCookieReason(net::CookieInclusionStatus status) {
   std::unique_ptr<Array<Network::CookieBlockedReason>> blockedReasons =
       std::make_unique<Array<Network::CookieBlockedReason>>();
 
   if (status.HasExclusionReason(
-          net::CanonicalCookie::CookieInclusionStatus::EXCLUDE_SECURE_ONLY)) {
+          net::CookieInclusionStatus::EXCLUDE_SECURE_ONLY)) {
     blockedReasons->push_back(Network::CookieBlockedReasonEnum::SecureOnly);
   }
   if (status.HasExclusionReason(
-          net::CanonicalCookie::CookieInclusionStatus::EXCLUDE_NOT_ON_PATH)) {
+          net::CookieInclusionStatus::EXCLUDE_NOT_ON_PATH)) {
     blockedReasons->push_back(Network::CookieBlockedReasonEnum::NotOnPath);
   }
-  if (status.HasExclusionReason(net::CanonicalCookie::CookieInclusionStatus::
-                                    EXCLUDE_DOMAIN_MISMATCH)) {
+  if (status.HasExclusionReason(
+          net::CookieInclusionStatus::EXCLUDE_DOMAIN_MISMATCH)) {
     blockedReasons->push_back(Network::CookieBlockedReasonEnum::DomainMismatch);
   }
-  if (status.HasExclusionReason(net::CanonicalCookie::CookieInclusionStatus::
-                                    EXCLUDE_SAMESITE_STRICT)) {
+  if (status.HasExclusionReason(
+          net::CookieInclusionStatus::EXCLUDE_SAMESITE_STRICT)) {
     blockedReasons->push_back(Network::CookieBlockedReasonEnum::SameSiteStrict);
   }
   if (status.HasExclusionReason(
-          net::CanonicalCookie::CookieInclusionStatus::EXCLUDE_SAMESITE_LAX)) {
+          net::CookieInclusionStatus::EXCLUDE_SAMESITE_LAX)) {
     blockedReasons->push_back(Network::CookieBlockedReasonEnum::SameSiteLax);
   }
   if (status.HasExclusionReason(
-          net::CanonicalCookie::CookieInclusionStatus::
+          net::CookieInclusionStatus::
               EXCLUDE_SAMESITE_UNSPECIFIED_TREATED_AS_LAX)) {
     blockedReasons->push_back(
         Network::CookieBlockedReasonEnum::SameSiteUnspecifiedTreatedAsLax);
   }
-  if (status.HasExclusionReason(net::CanonicalCookie::CookieInclusionStatus::
-                                    EXCLUDE_SAMESITE_NONE_INSECURE)) {
+  if (status.HasExclusionReason(
+          net::CookieInclusionStatus::EXCLUDE_SAMESITE_NONE_INSECURE)) {
     blockedReasons->push_back(
         Network::CookieBlockedReasonEnum::SameSiteNoneInsecure);
   }
-  if (status.HasExclusionReason(net::CanonicalCookie::CookieInclusionStatus::
-                                    EXCLUDE_USER_PREFERENCES)) {
+  if (status.HasExclusionReason(
+          net::CookieInclusionStatus::EXCLUDE_USER_PREFERENCES)) {
     blockedReasons->push_back(
         Network::CookieBlockedReasonEnum::UserPreferences);
   }
   if (status.HasExclusionReason(
-          net::CanonicalCookie::CookieInclusionStatus::EXCLUDE_UNKNOWN_ERROR)) {
+          net::CookieInclusionStatus::EXCLUDE_UNKNOWN_ERROR)) {
     blockedReasons->push_back(Network::CookieBlockedReasonEnum::UnknownError);
   }
 
@@ -683,16 +687,16 @@ BuildProtocolBlockedSetCookies(const net::CookieAndLineStatusList& net_list) {
 }
 
 std::unique_ptr<Array<Network::BlockedCookieWithReason>>
-BuildProtocolAssociatedCookies(const net::CookieStatusList& net_list) {
+BuildProtocolAssociatedCookies(const net::CookieAccessResultList& net_list) {
   auto protocol_list =
       std::make_unique<Array<Network::BlockedCookieWithReason>>();
 
-  for (const net::CookieWithStatus& cookie : net_list) {
+  for (const net::CookieWithAccessResult& cookie : net_list) {
     std::unique_ptr<Array<Network::CookieBlockedReason>> blocked_reasons =
-        GetProtocolBlockedCookieReason(cookie.status);
+        GetProtocolBlockedCookieReason(cookie.access_result.status);
     // Note that the condition below is not always true,
     // as there might be blocked reasons that we do not report.
-    if (blocked_reasons->size() || cookie.status.IsInclude()) {
+    if (blocked_reasons->size() || cookie.access_result.status.IsInclude()) {
       protocol_list->push_back(
           Network::BlockedCookieWithReason::Create()
               .SetBlockedReasons(std::move(blocked_reasons))
@@ -814,8 +818,7 @@ NetworkHandler::NetworkHandler(
   have_configured_service_worker_context = true;
 }
 
-NetworkHandler::~NetworkHandler() {
-}
+NetworkHandler::~NetworkHandler() = default;
 
 // static
 std::unique_ptr<Array<Network::Cookie>> NetworkHandler::BuildCookieArray(
@@ -1212,10 +1215,9 @@ void NetworkHandler::SetCookies(
     cookie_manager->SetCanonicalCookie(
         *cookie, net::cookie_util::SimulatedCookieSource(*cookie, "https"),
         options,
-        base::BindOnce(
-            [](base::RepeatingClosure callback,
-               net::CanonicalCookie::CookieInclusionStatus) { callback.Run(); },
-            barrier_closure));
+        base::BindOnce([](base::RepeatingClosure callback,
+                          net::CookieInclusionStatus) { callback.Run(); },
+                       barrier_closure));
   }
 }
 
@@ -1433,6 +1435,20 @@ std::unique_ptr<protocol::Object> BuildResponseHeaders(
   return std::make_unique<protocol::Object>(std::move(headers_dict));
 }
 
+String BuildServiceWorkerResponseSource(
+    const network::mojom::URLResponseHead& info) {
+  switch (info.service_worker_response_source) {
+    case network::mojom::FetchResponseSource::kCacheStorage:
+      return protocol::Network::ServiceWorkerResponseSourceEnum::CacheStorage;
+    case network::mojom::FetchResponseSource::kHttpCache:
+      return protocol::Network::ServiceWorkerResponseSourceEnum::HttpCache;
+    case network::mojom::FetchResponseSource::kNetwork:
+      return protocol::Network::ServiceWorkerResponseSourceEnum::Network;
+    case network::mojom::FetchResponseSource::kUnspecified:
+      return protocol::Network::ServiceWorkerResponseSourceEnum::FallbackCode;
+  }
+}
+
 std::unique_ptr<Network::Response> BuildResponse(
     const GURL& url,
     const network::mojom::URLResponseHead& info) {
@@ -1464,7 +1480,18 @@ std::unique_ptr<Network::Response> BuildResponse(
                                 info.load_timing.request_start_time)
           .Build();
   response->SetFromServiceWorker(info.was_fetched_via_service_worker);
+  if (info.was_fetched_via_service_worker) {
+    response->SetServiceWorkerResponseSource(
+        BuildServiceWorkerResponseSource(info));
+  }
   response->SetFromPrefetchCache(info.was_in_prefetch_cache);
+  if (!info.response_time.is_null()) {
+    response->SetResponseTime(info.response_time.ToJsTimeIgnoringNull());
+  }
+  if (!info.cache_storage_cache_name.empty()) {
+    response->SetCacheStorageCacheName(info.cache_storage_cache_name);
+  }
+
   auto* raw_info = info.raw_request_response_info.get();
   if (raw_info) {
     if (raw_info->http_status_code) {
@@ -2095,7 +2122,7 @@ void NetworkHandler::SetNetworkConditions(
 
 void NetworkHandler::OnRequestWillBeSentExtraInfo(
     const std::string& devtools_request_id,
-    const net::CookieStatusList& request_cookie_list,
+    const net::CookieAccessResultList& request_cookie_list,
     const std::vector<network::mojom::HttpRawHeaderPairPtr>& request_headers) {
   if (!enabled_)
     return;
diff --git a/chromium/content/browser/devtools/protocol/network_handler.h b/chromium/content/browser/devtools/protocol/network_handler.h
index 52b3c3421a2..e5f15a7a7b2 100644
--- a/chromium/content/browser/devtools/protocol/network_handler.h
+++ b/chromium/content/browser/devtools/protocol/network_handler.h
@@ -198,7 +198,7 @@ class NetworkHandler : public DevToolsDomainHandler,
 
   void OnRequestWillBeSentExtraInfo(
       const std::string& devtools_request_id,
-      const net::CookieStatusList& request_cookie_list,
+      const net::CookieAccessResultList& request_cookie_list,
       const std::vector<network::mojom::HttpRawHeaderPairPtr>& request_headers);
   void OnResponseReceivedExtraInfo(
       const std::string& devtools_request_id,
diff --git a/chromium/content/browser/devtools/protocol/page_handler.cc b/chromium/content/browser/devtools/protocol/page_handler.cc
index b1821434b97..630de0dd016 100644
--- a/chromium/content/browser/devtools/protocol/page_handler.cc
+++ b/chromium/content/browser/devtools/protocol/page_handler.cc
@@ -158,24 +158,12 @@ void GetMetadataFromFrame(const media::VideoFrame& frame,
                           double* page_scale_factor,
                           gfx::Vector2dF* root_scroll_offset,
                           double* top_controls_visible_height) {
-  // Get metadata from |frame| and ensure that no metadata is missing.
-  bool success = true;
-  double root_scroll_offset_x, root_scroll_offset_y;
-  success &= frame.metadata()->GetDouble(
-      media::VideoFrameMetadata::DEVICE_SCALE_FACTOR, device_scale_factor);
-  success &= frame.metadata()->GetDouble(
-      media::VideoFrameMetadata::PAGE_SCALE_FACTOR, page_scale_factor);
-  success &= frame.metadata()->GetDouble(
-      media::VideoFrameMetadata::ROOT_SCROLL_OFFSET_X, &root_scroll_offset_x);
-  success &= frame.metadata()->GetDouble(
-      media::VideoFrameMetadata::ROOT_SCROLL_OFFSET_Y, &root_scroll_offset_y);
-  success &= frame.metadata()->GetDouble(
-      media::VideoFrameMetadata::TOP_CONTROLS_VISIBLE_HEIGHT,
-      top_controls_visible_height);
-  DCHECK(success);
-
-  root_scroll_offset->set_x(root_scroll_offset_x);
-  root_scroll_offset->set_y(root_scroll_offset_y);
+  // Get metadata from |frame|. This will CHECK if metadata is missing.
+  *device_scale_factor = *frame.metadata()->device_scale_factor;
+  *page_scale_factor = *frame.metadata()->page_scale_factor;
+  root_scroll_offset->set_x(*frame.metadata()->root_scroll_offset_x);
+  root_scroll_offset->set_y(*frame.metadata()->root_scroll_offset_y);
+  *top_controls_visible_height = *frame.metadata()->top_controls_visible_height;
 }
 
 }  // namespace
@@ -338,8 +326,6 @@ void PageHandler::DidCloseJavaScriptDialog(bool success,
 
 Response PageHandler::Enable() {
   enabled_ = true;
-  if (GetWebContents() && GetWebContents()->ShowingInterstitialPage())
-    frontend_->InterstitialShown();
   return Response::FallThrough();
 }
 
@@ -510,7 +496,7 @@ void PageHandler::Navigate(const std::string& url,
   params.referrer = Referrer(GURL(referrer.fromMaybe("")), policy);
   params.transition_type = type;
   params.frame_tree_node_id = frame_tree_node->frame_tree_node_id();
-  frame_tree_node->navigator()->GetController()->LoadURLWithParams(params);
+  frame_tree_node->navigator().GetController()->LoadURLWithParams(params);
 
   base::UnguessableToken frame_token = frame_tree_node->devtools_frame_token();
   auto navigate_callback = navigate_callbacks_.find(frame_token);
@@ -892,8 +878,7 @@ Response PageHandler::StartScreencast(Maybe<std::string> format,
   if (frame_metadata_) {
     InnerSwapCompositorFrame();
   } else {
-    widget_host->Send(
-        new WidgetMsg_ForceRedraw(widget_host->GetRoutingID(), 0));
+    widget_host->RequestForceRedraw(0);
   }
   return Response::FallThrough();
 }
diff --git a/chromium/content/browser/devtools/protocol/schema_handler.cc b/chromium/content/browser/devtools/protocol/schema_handler.cc
index cc2210423a3..b09155489c3 100644
--- a/chromium/content/browser/devtools/protocol/schema_handler.cc
+++ b/chromium/content/browser/devtools/protocol/schema_handler.cc
@@ -13,8 +13,7 @@ SchemaHandler::SchemaHandler()
     : DevToolsDomainHandler(Schema::Metainfo::domainName) {
 }
 
-SchemaHandler::~SchemaHandler() {
-}
+SchemaHandler::~SchemaHandler() = default;
 
 void SchemaHandler::Wire(UberDispatcher* dispatcher) {
   Schema::Dispatcher::wire(dispatcher, this);
diff --git a/chromium/content/browser/devtools/protocol/security_handler.cc b/chromium/content/browser/devtools/protocol/security_handler.cc
index 51bbd3f9e93..9504ebcb4c7 100644
--- a/chromium/content/browser/devtools/protocol/security_handler.cc
+++ b/chromium/content/browser/devtools/protocol/security_handler.cc
@@ -120,8 +120,7 @@ SecurityHandler::SecurityHandler()
       host_(nullptr) {
 }
 
-SecurityHandler::~SecurityHandler() {
-}
+SecurityHandler::~SecurityHandler() = default;
 
 void SecurityHandler::Wire(UberDispatcher* dispatcher) {
   frontend_.reset(new Security::Frontend(dispatcher->channel()));
diff --git a/chromium/content/browser/devtools/protocol/service_worker_handler.cc b/chromium/content/browser/devtools/protocol/service_worker_handler.cc
index f370116a67b..7b3e63127d0 100644
--- a/chromium/content/browser/devtools/protocol/service_worker_handler.cc
+++ b/chromium/content/browser/devtools/protocol/service_worker_handler.cc
@@ -185,8 +185,7 @@ ServiceWorkerHandler::ServiceWorkerHandler(bool allow_inspect_worker)
       browser_context_(nullptr),
       storage_partition_(nullptr) {}
 
-ServiceWorkerHandler::~ServiceWorkerHandler() {
-}
+ServiceWorkerHandler::~ServiceWorkerHandler() = default;
 
 void ServiceWorkerHandler::Wire(UberDispatcher* dispatcher) {
   frontend_.reset(new ServiceWorker::Frontend(dispatcher->channel()));
@@ -438,10 +437,10 @@ void ServiceWorkerHandler::OnWorkerVersionUpdated(
     base::flat_set<std::string> client_set;
 
     for (const auto& client : version.clients) {
-      if (client.second.type ==
+      if (client.second.type() ==
           blink::mojom::ServiceWorkerClientType::kWindow) {
-        WebContents* web_contents =
-            WebContents::FromFrameTreeNodeId(client.second.frame_tree_node_id);
+        WebContents* web_contents = WebContents::FromFrameTreeNodeId(
+            client.second.GetFrameTreeNodeId());
         // There is a possibility that the frame is already deleted
         // because of the thread hopping.
         if (!web_contents)
diff --git a/chromium/content/browser/devtools/protocol/storage_handler.cc b/chromium/content/browser/devtools/protocol/storage_handler.cc
index 4d888297933..09be27dbb1e 100644
--- a/chromium/content/browser/devtools/protocol/storage_handler.cc
+++ b/chromium/content/browser/devtools/protocol/storage_handler.cc
@@ -12,7 +12,6 @@
 #include "base/bind.h"
 #include "base/strings/string_split.h"
 #include "base/strings/utf_string_conversions.h"
-#include "base/task/post_task.h"
 #include "content/browser/cache_storage/cache_storage_context_impl.h"
 #include "content/browser/devtools/protocol/browser_handler.h"
 #include "content/browser/devtools/protocol/network.h"
@@ -91,8 +90,8 @@ void GotUsageAndQuotaDataCallback(
     int64_t quota,
     blink::mojom::UsageBreakdownPtr usage_breakdown) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  base::PostTask(
-      FROM_HERE, {BrowserThread::UI},
+  GetUIThreadTaskRunner({})->PostTask(
+      FROM_HERE,
       base::BindOnce(ReportUsageAndQuotaDataOnUIThread, std::move(callback),
                      code, usage, quota, std::move(usage_breakdown)));
 }
@@ -391,8 +390,8 @@ void StorageHandler::GetUsageAndQuota(
   }
 
   storage::QuotaManager* manager = storage_partition_->GetQuotaManager();
-  base::PostTask(
-      FROM_HERE, {BrowserThread::IO},
+  GetIOThreadTaskRunner({})->PostTask(
+      FROM_HERE,
       base::BindOnce(&GetUsageAndQuotaOnIOThread, base::RetainedRef(manager),
                      url::Origin::Create(origin_url), std::move(callback)));
 }
diff --git a/chromium/content/browser/devtools/protocol/system_info_handler.cc b/chromium/content/browser/devtools/protocol/system_info_handler.cc
index 98d0e9cf218..58256d84a27 100644
--- a/chromium/content/browser/devtools/protocol/system_info_handler.cc
+++ b/chromium/content/browser/devtools/protocol/system_info_handler.cc
@@ -12,7 +12,6 @@
 #include "base/command_line.h"
 #include "base/process/process_metrics.h"
 #include "base/strings/utf_string_conversions.h"
-#include "base/task/post_task.h"
 #include "build/build_config.h"
 #include "content/browser/gpu/compositor_util.h"
 #include "content/browser/gpu/gpu_data_manager_impl.h"
@@ -107,10 +106,6 @@ class AuxGPUInfoEnumerator : public gpu::GPUInfo::Enumerator {
 
   void EndImageDecodeAcceleratorSupportedProfile() override {}
 
-  void BeginDx12VulkanVersionInfo() override {}
-
-  void EndDx12VulkanVersionInfo() override {}
-
   void BeginOverlayInfo() override {}
 
   void EndOverlayInfo() override {}
@@ -291,8 +286,8 @@ class SystemInfoHandlerGpuObserver : public content::GpuDataManagerObserver {
   explicit SystemInfoHandlerGpuObserver(
       std::unique_ptr<GetInfoCallback> callback)
       : callback_(std::move(callback)) {
-    base::PostDelayedTask(
-        FROM_HERE, {BrowserThread::UI},
+    GetUIThreadTaskRunner({})->PostDelayedTask(
+        FROM_HERE,
         base::BindOnce(&SystemInfoHandlerGpuObserver::ObserverWatchdogCallback,
                        weak_factory_.GetWeakPtr()),
         base::TimeDelta::FromMilliseconds(kGPUInfoWatchdogTimeoutMs));
@@ -339,8 +334,7 @@ SystemInfoHandler::SystemInfoHandler()
     : DevToolsDomainHandler(SystemInfo::Metainfo::domainName) {
 }
 
-SystemInfoHandler::~SystemInfoHandler() {
-}
+SystemInfoHandler::~SystemInfoHandler() = default;
 
 void SystemInfoHandler::Wire(UberDispatcher* dispatcher) {
   SystemInfo::Dispatcher::wire(dispatcher, this);
@@ -431,9 +425,8 @@ void SystemInfoHandler::GetProcessInfo(
   AddRendererProcessInfo(process_info.get());
 
   // Collect child processes info on the IO thread.
-  base::PostTaskAndReplyWithResult(
-      FROM_HERE, {BrowserThread::IO},
-      base::BindOnce(&AddChildProcessInfo, std::move(process_info)),
+  GetIOThreadTaskRunner({})->PostTaskAndReplyWithResult(
+      FROM_HERE, base::BindOnce(&AddChildProcessInfo, std::move(process_info)),
       base::BindOnce(&GetProcessInfoCallback::sendSuccess,
                      std::move(callback)));
 }
diff --git a/chromium/content/browser/devtools/protocol/target_auto_attacher.cc b/chromium/content/browser/devtools/protocol/target_auto_attacher.cc
index 3665d4ad309..666548fd8b0 100644
--- a/chromium/content/browser/devtools/protocol/target_auto_attacher.cc
+++ b/chromium/content/browser/devtools/protocol/target_auto_attacher.cc
@@ -94,17 +94,17 @@ base::flat_set<GURL> GetFrameUrls(RenderFrameHostImpl* render_frame_host) {
   //    (from WorkerCreated). See also https://crbug.com/907072
   //
   // We are not attaching in the following case:
-  // 4. Frame is trying to navigate and we _should_ pick up an existing SW but we don't.
-  //    We _could_ do this, but since we are not pausing the navigation, there
-  //    is no principal difference between picking up SW earlier or later.
+  // 4. Frame is trying to navigate and we _should_ pick up an existing SW but
+  //    we don't. We _could_ do this, but since we are not pausing the
+  //    navigation, there is no principal difference between picking up SW
+  //    earlier or later.
   //
   // We also try to detach from SW picked up for [3] if navigation has failed
   // (from DidFinishNavigation).
 
   base::flat_set<GURL> frame_urls;
   if (render_frame_host) {
-    for (FrameTreeNode* node :
-         render_frame_host->frame_tree_node()->frame_tree()->Nodes()) {
+    for (FrameTreeNode* node : render_frame_host->frame_tree()->Nodes()) {
       frame_urls.insert(node->current_url());
       // We use both old and new frame urls to support [3], where we attach while
       // navigation is still ongoing.
@@ -127,7 +127,7 @@ TargetAutoAttacher::TargetAutoAttacher(
       auto_attach_(false),
       wait_for_debugger_on_start_(false) {}
 
-TargetAutoAttacher::~TargetAutoAttacher() {}
+TargetAutoAttacher::~TargetAutoAttacher() = default;
 
 void TargetAutoAttacher::SetRenderFrameHost(
     RenderFrameHostImpl* render_frame_host) {
@@ -362,16 +362,6 @@ void TargetAutoAttacher::WorkerCreated(ServiceWorkerDevToolsAgentHost* host,
   }
 }
 
-void TargetAutoAttacher::WorkerVersionInstalled(
-    ServiceWorkerDevToolsAgentHost* host) {
-  ReattachServiceWorkers(false);
-}
-
-void TargetAutoAttacher::WorkerVersionDoomed(
-    ServiceWorkerDevToolsAgentHost* host) {
-  ReattachServiceWorkers(false);
-}
-
 void TargetAutoAttacher::WorkerDestroyed(ServiceWorkerDevToolsAgentHost* host) {
   if (is_browser_mode()) {
     auto_attached_hosts_.erase(base::WrapRefCounted(host));
diff --git a/chromium/content/browser/devtools/protocol/target_auto_attacher.h b/chromium/content/browser/devtools/protocol/target_auto_attacher.h
index 181819cf592..96e72cc13b7 100644
--- a/chromium/content/browser/devtools/protocol/target_auto_attacher.h
+++ b/chromium/content/browser/devtools/protocol/target_auto_attacher.h
@@ -60,8 +60,6 @@ class TargetAutoAttacher : public ServiceWorkerDevToolsManager::Observer {
   // ServiceWorkerDevToolsManager::Observer implementation.
   void WorkerCreated(ServiceWorkerDevToolsAgentHost* host,
                      bool* should_pause_on_start) override;
-  void WorkerVersionInstalled(ServiceWorkerDevToolsAgentHost* host) override;
-  void WorkerVersionDoomed(ServiceWorkerDevToolsAgentHost* host) override;
   void WorkerDestroyed(ServiceWorkerDevToolsAgentHost* host) override;
 
   void UpdateFrames();
diff --git a/chromium/content/browser/devtools/protocol/target_handler.cc b/chromium/content/browser/devtools/protocol/target_handler.cc
index 4614ecae211..dda5c814235 100644
--- a/chromium/content/browser/devtools/protocol/target_handler.cc
+++ b/chromium/content/browser/devtools/protocol/target_handler.cc
@@ -30,6 +30,35 @@ namespace protocol {
 
 namespace {
 
+constexpr net::NetworkTrafficAnnotationTag
+    kSettingsProxyConfigTrafficAnnotation =
+        net::DefineNetworkTrafficAnnotation("devtools_proxy_config", R"(
+      semantics {
+        sender: "Proxy Configuration over Developer Tools"
+        description:
+          "Used to fetch HTTP/HTTPS/SOCKS5/PAC proxy configuration when "
+          "proxy is configured by DevTools. It is equivalent to the one "
+          "configured via the --proxy-server command line flag. "
+          "When proxy implies automatic configuration, it can send network "
+          "requests in the scope of this annotation."
+        trigger:
+          "Whenever a network request is made when the system proxy settings "
+          "are used, and they indicate to use a proxy server."
+        data:
+          "Proxy configuration."
+        destination: OTHER
+        destination_other: "The proxy server specified in the configuration."
+      }
+      policy {
+        cookies_allowed: NO
+        setting:
+          "This request cannot be disabled in settings. However it will never "
+          "be made if user does not run with '--remote-debugging-*' switches "
+          "and does not explicitly send this data over Chrome remote debugging."
+        policy_exception_justification:
+          "Not implemented, only used in DevTools and is behind a switch."
+      })");
+
 static const char kNotAllowedError[] = "Not allowed";
 static const char kMethod[] = "method";
 static const char kResumeMethod[] = "Runtime.runIfWaitingForDebugger";
@@ -436,7 +465,7 @@ class TargetHandler::Session : public DevToolsAgentHostClient {
       // was introduced. Try a DCHECK instead and possibly remove the check.
       if (!handler_->root_session_->HasChildSession(id_))
         return;
-      handler_->root_session_->GetClient()->DispatchProtocolMessage(
+      GetRootClient()->DispatchProtocolMessage(
           handler_->root_session_->GetAgentHost(), message);
       return;
     }
@@ -454,6 +483,26 @@ class TargetHandler::Session : public DevToolsAgentHostClient {
     Detach(true);
   }
 
+  bool MayAttachToURL(const GURL& url, bool is_webui) override {
+    return GetRootClient()->MayAttachToURL(url, is_webui);
+  }
+
+  bool MayAttachToBrowser() override {
+    return GetRootClient()->MayAttachToBrowser();
+  }
+
+  bool MayReadLocalFiles() override {
+    return GetRootClient()->MayReadLocalFiles();
+  }
+
+  bool MayWriteLocalFiles() override {
+    return GetRootClient()->MayWriteLocalFiles();
+  }
+
+  content::DevToolsAgentHostClient* GetRootClient() {
+    return handler_->root_session_->GetClient();
+  }
+
   TargetHandler* handler_;
   scoped_refptr<DevToolsAgentHost> agent_host_;
   std::string id_;
@@ -520,8 +569,7 @@ TargetHandler::TargetHandler(AccessMode access_mode,
       owner_target_id_(owner_target_id),
       root_session_(root_session) {}
 
-TargetHandler::~TargetHandler() {
-}
+TargetHandler::~TargetHandler() = default;
 
 // static
 std::vector<TargetHandler*> TargetHandler::ForAgentHost(
@@ -560,6 +608,7 @@ Response TargetHandler::Disable() {
     }
     dispose_on_detach_context_ids_.clear();
   }
+  contexts_with_overridden_proxy_.clear();
   return Response::Success();
 }
 
@@ -948,23 +997,50 @@ void TargetHandler::DevToolsAgentHostCrashed(DevToolsAgentHost* host,
 
 // ----------------- More protocol methods -------------------
 
-protocol::Response TargetHandler::CreateBrowserContext(
-    Maybe<bool> dispose_on_detach,
-    std::string* out_context_id) {
-  if (access_mode_ != AccessMode::kBrowser)
-    return Response::ServerError(kNotAllowedError);
+void TargetHandler::CreateBrowserContext(
+    Maybe<bool> in_disposeOnDetach,
+    Maybe<String> in_proxyServer,
+    Maybe<String> in_proxyBypassList,
+    std::unique_ptr<CreateBrowserContextCallback> callback) {
+  if (access_mode_ != AccessMode::kBrowser) {
+    callback->sendFailure(Response::ServerError(kNotAllowedError));
+    return;
+  }
   DevToolsManagerDelegate* delegate =
       DevToolsManager::GetInstance()->delegate();
-  if (!delegate)
-    return Response::ServerError(
-        "Browser context management is not supported.");
+  if (!delegate) {
+    callback->sendFailure(
+        Response::ServerError("Browser context management is not supported."));
+    return;
+  }
+
+  if (in_proxyServer.isJust()) {
+    pending_proxy_config_ = net::ProxyConfig();
+    pending_proxy_config_->proxy_rules().ParseFromString(
+        in_proxyServer.fromJust());
+    if (in_proxyBypassList.isJust()) {
+      pending_proxy_config_->proxy_rules().bypass_rules.ParseFromString(
+          in_proxyBypassList.fromJust());
+    }
+  }
+
   BrowserContext* context = delegate->CreateBrowserContext();
-  if (!context)
-    return Response::ServerError("Failed to create browser context.");
-  *out_context_id = context->UniqueId();
-  if (dispose_on_detach.fromMaybe(false))
-    dispose_on_detach_context_ids_.insert(*out_context_id);
-  return Response::Success();
+  if (!context) {
+    callback->sendFailure(
+        Response::ServerError("Failed to create browser context."));
+    pending_proxy_config_.reset();
+    return;
+  }
+
+  if (pending_proxy_config_) {
+    contexts_with_overridden_proxy_[context->UniqueId()] =
+        std::move(*pending_proxy_config_);
+    pending_proxy_config_.reset();
+  }
+
+  if (in_disposeOnDetach.fromMaybe(false))
+    dispose_on_detach_context_ids_.insert(context->UniqueId());
+  callback->sendSuccess(context->UniqueId());
 }
 
 protocol::Response TargetHandler::GetBrowserContexts(
@@ -1024,5 +1100,25 @@ void TargetHandler::DisposeBrowserContext(
           std::move(callback)));
 }
 
+void TargetHandler::ApplyNetworkContextParamsOverrides(
+    BrowserContext* browser_context,
+    network::mojom::NetworkContextParams* context_params) {
+  // Under certain conditions, storage partition is created synchronously for
+  // the browser context. Account for this use case.
+  if (pending_proxy_config_) {
+    context_params->initial_proxy_config =
+        net::ProxyConfigWithAnnotation(std::move(*pending_proxy_config_),
+                                       kSettingsProxyConfigTrafficAnnotation);
+    pending_proxy_config_.reset();
+    return;
+  }
+  auto it = contexts_with_overridden_proxy_.find(browser_context->UniqueId());
+  if (it != contexts_with_overridden_proxy_.end()) {
+    context_params->initial_proxy_config = net::ProxyConfigWithAnnotation(
+        std::move(it->second), kSettingsProxyConfigTrafficAnnotation);
+    contexts_with_overridden_proxy_.erase(browser_context->UniqueId());
+  }
+}
+
 }  // namespace protocol
 }  // namespace content
diff --git a/chromium/content/browser/devtools/protocol/target_handler.h b/chromium/content/browser/devtools/protocol/target_handler.h
index e410f6d96ca..83437c80f24 100644
--- a/chromium/content/browser/devtools/protocol/target_handler.h
+++ b/chromium/content/browser/devtools/protocol/target_handler.h
@@ -8,12 +8,15 @@
 #include <map>
 #include <set>
 
+#include "base/containers/flat_map.h"
 #include "base/containers/flat_set.h"
 #include "base/memory/weak_ptr.h"
 #include "content/browser/devtools/protocol/devtools_domain_handler.h"
 #include "content/browser/devtools/protocol/target.h"
 #include "content/browser/devtools/protocol/target_auto_attacher.h"
 #include "content/public/browser/devtools_agent_host_observer.h"
+#include "net/proxy_resolution/proxy_config.h"
+#include "services/network/public/mojom/network_context.mojom.h"
 
 namespace content {
 
@@ -85,8 +88,11 @@ class TargetHandler : public DevToolsDomainHandler,
                        bool* out_success) override;
   Response ExposeDevToolsProtocol(const std::string& target_id,
                                   Maybe<std::string> binding_name) override;
-  Response CreateBrowserContext(Maybe<bool> dispose_on_detach,
-                                std::string* out_context_id) override;
+  void CreateBrowserContext(
+      Maybe<bool> in_disposeOnDetach,
+      Maybe<String> in_proxyServer,
+      Maybe<String> in_proxyBypassList,
+      std::unique_ptr<CreateBrowserContextCallback> callback) override;
   void DisposeBrowserContext(
       const std::string& context_id,
       std::unique_ptr<DisposeBrowserContextCallback> callback) override;
@@ -104,6 +110,10 @@ class TargetHandler : public DevToolsDomainHandler,
       std::unique_ptr<protocol::Array<Target::TargetInfo>>* target_infos)
       override;
 
+  void ApplyNetworkContextParamsOverrides(
+      BrowserContext* browser_context,
+      network::mojom::NetworkContextParams* network_context_params);
+
  private:
   class Session;
   class Throttle;
@@ -143,10 +153,12 @@ class TargetHandler : public DevToolsDomainHandler,
   std::map<DevToolsAgentHost*, Session*> auto_attached_sessions_;
   std::set<DevToolsAgentHost*> reported_hosts_;
   base::flat_set<std::string> dispose_on_detach_context_ids_;
+  base::flat_map<std::string, net::ProxyConfig> contexts_with_overridden_proxy_;
   AccessMode access_mode_;
   std::string owner_target_id_;
   DevToolsSession* root_session_;
   base::flat_set<Throttle*> throttles_;
+  base::Optional<net::ProxyConfig> pending_proxy_config_;
   base::WeakPtrFactory<TargetHandler> weak_factory_{this};
 
   DISALLOW_COPY_AND_ASSIGN(TargetHandler);
diff --git a/chromium/content/browser/devtools/protocol/tethering_handler.cc b/chromium/content/browser/devtools/protocol/tethering_handler.cc
index 84e16553bfa..315b645ab79 100644
--- a/chromium/content/browser/devtools/protocol/tethering_handler.cc
+++ b/chromium/content/browser/devtools/protocol/tethering_handler.cc
@@ -7,7 +7,6 @@
 #include <map>
 
 #include "base/bind.h"
-#include "base/task/post_task.h"
 #include "content/public/browser/browser_task_traits.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/io_buffer.h"
@@ -288,8 +287,8 @@ TetheringHandler::TetheringImpl::~TetheringImpl() = default;
 void TetheringHandler::TetheringImpl::Bind(
     uint16_t port, std::unique_ptr<BindCallback> callback) {
   if (bound_sockets_.find(port) != bound_sockets_.end()) {
-    base::PostTask(
-        FROM_HERE, {BrowserThread::UI},
+    GetUIThreadTaskRunner({})->PostTask(
+        FROM_HERE,
         base::BindOnce(&BindCallback::sendFailure, std::move(callback),
                        Response::ServerError("Port already bound")));
     return;
@@ -300,16 +299,16 @@ void TetheringHandler::TetheringImpl::Bind(
   std::unique_ptr<BoundSocket> bound_socket = std::make_unique<BoundSocket>(
       std::move(accepted_callback), socket_callback_);
   if (!bound_socket->Listen(port)) {
-    base::PostTask(
-        FROM_HERE, {BrowserThread::UI},
+    GetUIThreadTaskRunner({})->PostTask(
+        FROM_HERE,
         base::BindOnce(&BindCallback::sendFailure, std::move(callback),
                        Response::ServerError("Could not bind port")));
     return;
   }
 
   bound_sockets_[port] = std::move(bound_socket);
-  base::PostTask(
-      FROM_HERE, {BrowserThread::UI},
+  GetUIThreadTaskRunner({})->PostTask(
+      FROM_HERE,
       base::BindOnce(&BindCallback::sendSuccess, std::move(callback)));
 }
 
@@ -317,23 +316,23 @@ void TetheringHandler::TetheringImpl::Unbind(
     uint16_t port, std::unique_ptr<UnbindCallback> callback) {
   auto it = bound_sockets_.find(port);
   if (it == bound_sockets_.end()) {
-    base::PostTask(
-        FROM_HERE, {BrowserThread::UI},
+    GetUIThreadTaskRunner({})->PostTask(
+        FROM_HERE,
         base::BindOnce(&UnbindCallback::sendFailure, std::move(callback),
                        Response::InvalidParams("Port is not bound")));
     return;
   }
 
   bound_sockets_.erase(it);
-  base::PostTask(
-      FROM_HERE, {BrowserThread::UI},
+  GetUIThreadTaskRunner({})->PostTask(
+      FROM_HERE,
       base::BindOnce(&UnbindCallback::sendSuccess, std::move(callback)));
 }
 
 void TetheringHandler::TetheringImpl::Accepted(uint16_t port,
                                                const std::string& name) {
-  base::PostTask(
-      FROM_HERE, {BrowserThread::UI},
+  GetUIThreadTaskRunner({})->PostTask(
+      FROM_HERE,
       base::BindOnce(&TetheringHandler::Accepted, handler_, port, name));
 }
 
diff --git a/chromium/content/browser/devtools/protocol/tracing_handler.cc b/chromium/content/browser/devtools/protocol/tracing_handler.cc
index 058e5b1e9ff..872b74e0ccf 100644
--- a/chromium/content/browser/devtools/protocol/tracing_handler.cc
+++ b/chromium/content/browser/devtools/protocol/tracing_handler.cc
@@ -18,7 +18,6 @@
 #include "base/memory/ref_counted_memory.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
-#include "base/task/post_task.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "base/trace_event/memory_dump_manager.h"
@@ -142,8 +141,8 @@ class DevToolsStreamEndpoint : public TracingController::TraceDataEndpoint {
 
   void ReceiveTraceChunk(std::unique_ptr<std::string> chunk) override {
     if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
-      base::PostTask(FROM_HERE, {BrowserThread::UI},
-                     base::BindOnce(&DevToolsStreamEndpoint::ReceiveTraceChunk,
+      GetUIThreadTaskRunner({})->PostTask(
+          FROM_HERE, base::BindOnce(&DevToolsStreamEndpoint::ReceiveTraceChunk,
                                     this, std::move(chunk)));
       return;
     }
@@ -153,8 +152,8 @@ class DevToolsStreamEndpoint : public TracingController::TraceDataEndpoint {
 
   void ReceivedTraceFinalContents() override {
     if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
-      base::PostTask(
-          FROM_HERE, {BrowserThread::UI},
+      GetUIThreadTaskRunner({})->PostTask(
+          FROM_HERE,
           base::BindOnce(&DevToolsStreamEndpoint::ReceivedTraceFinalContents,
                          this));
       return;
@@ -759,8 +758,8 @@ void TracingHandler::Start(Maybe<std::string> categories,
   }
 
   // GPU process id can only be retrieved on IO thread. Do some thread hopping.
-  base::PostTaskAndReplyWithResult(
-      FROM_HERE, {BrowserThread::IO}, base::BindOnce([]() {
+  GetIOThreadTaskRunner({})->PostTaskAndReplyWithResult(
+      FROM_HERE, base::BindOnce([]() {
         GpuProcessHost* gpu_process_host =
             GpuProcessHost::Get(GPU_PROCESS_KIND_SANDBOXED,
                                 /* force_create */ false);
@@ -953,10 +952,7 @@ void TracingHandler::OnFrameFromVideoConsumer(
     scoped_refptr<media::VideoFrame> frame) {
   const SkBitmap skbitmap = DevToolsVideoConsumer::GetSkBitmapFromFrame(frame);
 
-  base::TimeTicks reference_time;
-  const bool had_reference_time = frame->metadata()->GetTimeTicks(
-      media::VideoFrameMetadata::REFERENCE_TIME, &reference_time);
-  DCHECK(had_reference_time);
+  base::TimeTicks reference_time = *frame->metadata()->reference_time;
 
   TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID_AND_TIMESTAMP(
       TRACE_DISABLED_BY_DEFAULT("devtools.screenshot"), "Screenshot", 1,