Google Git
Sign in
chromium / chromium / src / d4203a2215..09ff114191 / .
diff --git a/DEPS b/DEPS
index 1fe6e40..830c4c4 100644
--- a/DEPS
+++ b/DEPS

@@ -195,11 +195,11 @@
   # Three lines of non-changing comments so that
   # the commit queue can handle CLs rolling Skia
   # and whatever else without interference from each other.
-  'skia_revision': '3cce1125f0272644cec9b07173d0fb56f3cf1052',
+  'skia_revision': '3c02c934afa7f0128b113ce298346fb17d695dac',
   # Three lines of non-changing comments so that
   # the commit queue can handle CLs rolling V8
   # and whatever else without interference from each other.
-  'v8_revision': '288014f2f94b4ff0fb0bb160ffac61b7bc3e7739',
+  'v8_revision': '1dec2f312a7256de85c67fb4745e58b3222197c4',
   # Three lines of non-changing comments so that
   # the commit queue can handle CLs rolling swarming_client
   # and whatever else without interference from each other.
@@ -207,7 +207,7 @@
   # Three lines of non-changing comments so that
   # the commit queue can handle CLs rolling ANGLE
   # and whatever else without interference from each other.
-  'angle_revision': 'd19c08c9ed8ded0306039af4cdc4a93ce18e3742',
+  'angle_revision': '3c2454b82c050193b8552000f1a9e208928d07e6',
   # Three lines of non-changing comments so that
   # the commit queue can handle CLs rolling SwiftShader
   # and whatever else without interference from each other.
@@ -266,7 +266,7 @@
   # Three lines of non-changing comments so that
   # the commit queue can handle CLs rolling devtools-frontend
   # and whatever else without interference from each other.
-  'devtools_frontend_revision': 'b8ae5a73f8754a47acc50f4c1d7461e8a6fd5e26',
+  'devtools_frontend_revision': 'ac636dc7dfe037669835bba1bb5ab317345640c4',
   # Three lines of non-changing comments so that
   # the commit queue can handle CLs rolling libprotobuf-mutator
   # and whatever else without interference from each other.
@@ -314,7 +314,7 @@
   # Three lines of non-changing comments so that
   # the commit queue can handle CLs rolling feed
   # and whatever else without interference from each other.
-  'shaderc_revision': '21b36f7368092216ecfaa017e95c383c2ed9db70',
+  'shaderc_revision': 'b6c82a149ed87cab37f2364ecd6f27423cfab8ba',
   # Three lines of non-changing comments so that
   # the commit queue can handle CLs rolling feed
   # and whatever else without interference from each other.
@@ -322,7 +322,7 @@
   # Three lines of non-changing comments so that
   # the commit queue can handle CLs rolling feed
   # and whatever else without interference from each other.
-  'quiche_revision': 'c7f8b47a1b55d5d85bff73a8ebf64b1c9c4ab8c2',
+  'quiche_revision': 'c2e5361f375a0354cd0eb7cf6dea1e0c19555a4f',
   # Three lines of non-changing comments so that
   # the commit queue can handle CLs rolling ios_webkit
   # and whatever else without interference from each other.
@@ -357,7 +357,7 @@
   'ukey2_revision': '0275885d8e6038c39b8a8ca55e75d1d4d1727f47',
   # the commit queue can handle CLs rolling feed
   # and whatever else without interference from each other.
-  'tint_revision': 'b08e25388629f5a8f467b726ace18df529bba3ef',
+  'tint_revision': 'f70065f6222776f60738099b1c1319c9fbc36627',
 
   # TODO(crbug.com/941824): The values below need to be kept in sync
   # between //DEPS and //buildtools/DEPS, so if you're updating one,
@@ -895,7 +895,7 @@
   },
 
   'src/third_party/depot_tools':
-    Var('chromium_git') + '/chromium/tools/depot_tools.git' + '@' + 'b09f2bb2f282727b3316c30659e2998ac4f1a373',
+    Var('chromium_git') + '/chromium/tools/depot_tools.git' + '@' + 'dff2104727dc207f58d87b938e04402be548329c',
 
   'src/third_party/devtools-frontend/src':
     Var('chromium_git') + '/devtools/devtools-frontend' + '@' + Var('devtools_frontend_revision'),
@@ -1090,7 +1090,7 @@
     Var('chromium_git') + '/external/libaddressinput.git' + '@' + '390dfc08e3806a2125d08d4d8d034a24d587d77a',
 
   'src/third_party/libaom/source/libaom':
-    Var('aomedia_git') + '/aom.git' + '@' +  '4dcbd921c3a686185c705eeccb154da52858d23b',
+    Var('aomedia_git') + '/aom.git' + '@' +  'e2219b84bc9d723e26ae6618beecad045612017e',
 
   'src/third_party/libavif/src':
     Var('chromium_git') + '/external/github.com/AOMediaCodec/libavif.git' + '@' + Var('libavif_revision'),
@@ -1542,7 +1542,7 @@
     Var('chromium_git') + '/v8/v8.git' + '@' +  Var('v8_revision'),
 
   'src-internal': {
-    'url': 'https://chrome-internal.googlesource.com/chrome/src-internal.git@65f9045b37a9f02731008b8f71d86bb9db4f0444',
+    'url': 'https://chrome-internal.googlesource.com/chrome/src-internal.git@13e23939fb1a500d1748b3a2a89ee3854404329b',
     'condition': 'checkout_src_internal',
   },
 
@@ -1561,7 +1561,7 @@
     'packages': [
       {
         'package': 'chromeos_internal/apps/media_app/app',
-        'version': 'WmaW9qZKgz71XJS-eJaYWm5I75Joraecva9PEaQvP0wC',
+        'version': 'gK0jWjCbv2pog8c8oLyWz6k0XrWhmsjGf59KCV9AIcgC',
       },
     ],
     'condition': 'checkout_chromeos and checkout_src_internal',

diff --git a/android_webview/javatests/src/org/chromium/android_webview/test/AwContentCaptureTest.java b/android_webview/javatests/src/org/chromium/android_webview/test/AwContentCaptureTest.java
index c2ef87f..2bdaaba 100644
--- a/android_webview/javatests/src/org/chromium/android_webview/test/AwContentCaptureTest.java
+++ b/android_webview/javatests/src/org/chromium/android_webview/test/AwContentCaptureTest.java

@@ -5,6 +5,7 @@
 package org.chromium.android_webview.test;
 
 import android.graphics.Rect;
+import android.net.Uri;
 
 import androidx.test.filters.LargeTest;
 import androidx.test.filters.SmallTest;
@@ -23,6 +24,7 @@
 import org.chromium.components.content_capture.ContentCaptureConsumer;
 import org.chromium.components.content_capture.ContentCaptureController;
 import org.chromium.components.content_capture.ContentCaptureData;
+import org.chromium.components.content_capture.ExperimentContentCaptureConsumer;
 import org.chromium.components.content_capture.FrameSession;
 import org.chromium.content_public.browser.WebContents;
 import org.chromium.content_public.browser.test.util.TestThreadUtils;
@@ -57,6 +59,7 @@
             String[] allowlist = null;
             boolean[] isRegEx = null;
             if (mAllowlist != null && mIsRegEx != null) {
+                allowlist = new String[mAllowlist.size()];
                 mAllowlist.toArray(allowlist);
                 isRegEx = new boolean[mAllowlist.size()];
                 int i = 0;
@@ -67,6 +70,13 @@
             setAllowlist(allowlist, isRegEx);
         }
 
+        public void setAllowURL(String host) {
+            mAllowlist = new ArrayList<String>();
+            mAllowlist.add(host);
+            mIsRegEx = new ArrayList<Boolean>();
+            mIsRegEx.add(Boolean.FALSE);
+        }
+
         private ArrayList<String> mAllowlist;
         private ArrayList<Boolean> mIsRegEx;
     }
@@ -84,6 +94,10 @@
             mCapturedContentIds = new HashSet<Long>();
         }
 
+        public void setContentCaptureController(ContentCaptureController controller) {
+            mController = controller;
+        }
+
         @Override
         public void onContentCaptured(
                 FrameSession parentFrame, ContentCaptureData contentCaptureData) {
@@ -124,6 +138,12 @@
             mCallbackHelper.notifyCalled();
         }
 
+        @Override
+        public boolean shouldCapture(String[] urls) {
+            if (mController == null) return true;
+            return mController.shouldCapture(urls);
+        }
+
         public FrameSession getParentFrame() {
             return mParentFrame;
         }
@@ -187,6 +207,7 @@
 
         // Use our own call count to avoid unexpected callback issue.
         private int mCallCount;
+        // TODO: (crbug.com/1121827) Remove volatile if possible.
         private volatile Set<Long> mCapturedContentIds;
         private volatile FrameSession mParentFrame;
         private volatile ContentCaptureData mCapturedContent;
@@ -197,6 +218,7 @@
         private volatile ArrayList<Integer> mCallbacks = new ArrayList<Integer>();
 
         private CallbackHelper mCallbackHelper = new CallbackHelper();
+        private volatile ContentCaptureController mController;
     }
 
     private static final String MAIN_FRAME_FILE = "/main_frame.html";
@@ -212,6 +234,7 @@
     private AwTestContainerView mContainerView;
     private TestAwContentCaptureConsumer mConsumer;
     private TestAwContentCatpureController mController;
+    private TestAwContentCaptureConsumer mSecondConsumer;
 
     private void loadUrlSync(String url) {
         try {
@@ -582,4 +605,86 @@
         }, toIntArray(TestAwContentCaptureConsumer.SESSION_REMOVED));
         verifyFrameSession(removedSession, mConsumer.getRemovedSession());
     }
+
+    @Test
+    @SmallTest
+    @Feature({"AndroidWebView"})
+    public void testMultipleConsumers() throws Throwable {
+        TestThreadUtils.runOnUiThreadBlocking(() -> {
+            mSecondConsumer = new TestAwContentCaptureConsumer(mAwContents.getWebContents());
+        });
+        final String response = "<html><head></head><body>"
+                + "<div id='place_holder'>"
+                + "<p style=\"height: 100vh\">Hello</p>"
+                + "<p>world</p>"
+                + "</body></html>";
+        final String url = mWebServer.setResponse(MAIN_FRAME_FILE, response, null);
+        runAndVerifyCallbacks(() -> {
+            loadUrlSync(url);
+        }, toIntArray(TestAwContentCaptureConsumer.CONTENT_CAPTURED));
+        // Verify the other one also get the content.
+        verifyCallbacks(toIntArray(TestAwContentCaptureConsumer.CONTENT_CAPTURED),
+                mSecondConsumer.getCallbacks());
+    }
+
+    @Test
+    @SmallTest
+    @Feature({"AndroidWebView"})
+    @CommandLineFlags.Add({"enable-features=ContentCaptureTriggeringForExperiment"})
+    public void testHostNotAllowed() throws Throwable {
+        TestThreadUtils.runOnUiThreadBlocking(() -> {
+            mSecondConsumer = new TestAwContentCaptureConsumer(mAwContents.getWebContents());
+        });
+        final String response = "<html><head></head><body>"
+                + "<div id='place_holder'>"
+                + "<p style=\"height: 100vh\">Hello</p>"
+                + "<p>world</p>"
+                + "</body></html>";
+        final String url = mWebServer.setResponse(MAIN_FRAME_FILE, response, null);
+        mController.setAllowURL("www.chromium.org");
+        mSecondConsumer.setContentCaptureController(mController);
+        runAndVerifyCallbacks(() -> {
+            loadUrlSync(url);
+        }, toIntArray(TestAwContentCaptureConsumer.CONTENT_CAPTURED));
+        // Verify the other one didn't get the content.
+        Assert.assertEquals(0, mSecondConsumer.getCallbacks().length);
+    }
+
+    private void runHostAllowedTest() throws Throwable {
+        final String response = "<html><head></head><body>"
+                + "<div id='place_holder'>"
+                + "<p style=\"height: 100vh\">Hello</p>"
+                + "<p>world</p>"
+                + "</body></html>";
+        final String url = mWebServer.setResponse(MAIN_FRAME_FILE, response, null);
+        mController.setAllowURL(Uri.parse(url).getHost());
+        mConsumer.setContentCaptureController(mController);
+        runAndVerifyCallbacks(() -> {
+            loadUrlSync(url);
+        }, toIntArray(TestAwContentCaptureConsumer.CONTENT_CAPTURED));
+    }
+
+    @Test
+    @SmallTest
+    @Feature({"AndroidWebView"})
+    @CommandLineFlags.Add({"disable-features=ContentCaptureTriggeringForExperiment"})
+    public void testHostAllowed() throws Throwable {
+        runHostAllowedTest();
+    }
+
+    @Test
+    @SmallTest
+    @Feature({"AndroidWebView"})
+    @CommandLineFlags.Add({"enable-features=ContentCaptureTriggeringForExperiment"})
+    public void testHostAllowedForExperiment() throws Throwable {
+        runHostAllowedTest();
+    }
+
+    @Test
+    @SmallTest
+    @Feature({"AndroidWebView"})
+    @CommandLineFlags.Add({"disable-features=ContentCaptureTriggeringForExperiment"})
+    public void testCantCreateExperimentConsumer() throws Throwable {
+        Assert.assertNull(ExperimentContentCaptureConsumer.create(mAwContents.getWebContents()));
+    }
 }

diff --git a/ash/BUILD.gn b/ash/BUILD.gn
index f4f87edc7..34f9814 100644
--- a/ash/BUILD.gn
+++ b/ash/BUILD.gn

@@ -284,6 +284,9 @@
     "clipboard/clipboard_history_resource_manager.h",
     "clipboard/clipboard_history_util.cc",
     "clipboard/clipboard_history_util.h",
+    "clipboard/clipboard_nudge_constants.h",
+    "clipboard/clipboard_nudge_controller.cc",
+    "clipboard/clipboard_nudge_controller.h",
     "clipboard/views/clipboard_history_bitmap_item_view.cc",
     "clipboard/views/clipboard_history_bitmap_item_view.h",
     "clipboard/views/clipboard_history_item_view.cc",
@@ -943,6 +946,8 @@
     "system/locale/unified_locale_detailed_view_controller.h",
     "system/machine_learning/user_settings_event_logger.cc",
     "system/machine_learning/user_settings_event_logger.h",
+    "system/media/media_tray.cc",
+    "system/media/media_tray.h",
     "system/message_center/arc_notification_manager_delegate_impl.cc",
     "system/message_center/arc_notification_manager_delegate_impl.h",
     "system/message_center/ash_message_center_lock_screen_controller.cc",
@@ -1829,6 +1834,7 @@
     "clipboard/clipboard_history_resource_manager_unittest.cc",
     "clipboard/clipboard_history_unittest.cc",
     "clipboard/clipboard_history_util_unittest.cc",
+    "clipboard/clipboard_nudge_controller_unittest.cc",
     "dbus/gesture_properties_service_provider_unittest.cc",
     "dbus/url_handler_service_provider_unittest.cc",
     "detachable_base/detachable_base_handler_unittest.cc",

diff --git a/ash/ash_prefs.cc b/ash/ash_prefs.cc
index d7f2776..21c35b0 100644
--- a/ash/ash_prefs.cc
+++ b/ash/ash_prefs.cc

@@ -8,6 +8,7 @@
 #include "ash/ambient/ambient_controller.h"
 #include "ash/app_list/app_list_controller_impl.h"
 #include "ash/assistant/assistant_controller_impl.h"
+#include "ash/clipboard/clipboard_nudge_controller.h"
 #include "ash/detachable_base/detachable_base_handler.h"
 #include "ash/display/display_prefs.h"
 #include "ash/display/privacy_screen_controller.h"
@@ -50,6 +51,7 @@
   BluetoothPowerController::RegisterProfilePrefs(registry);
   CapsLockNotificationController::RegisterProfilePrefs(registry, for_test);
   contextual_tooltip::RegisterProfilePrefs(registry);
+  ClipboardNudgeController::RegisterProfilePrefs(registry);
   desks_restore_util::RegisterProfilePrefs(registry);
   DockedMagnifierControllerImpl::RegisterProfilePrefs(registry);
   GestureEducationNotificationController::RegisterProfilePrefs(registry,

diff --git a/ash/ash_strings.grd b/ash/ash_strings.grd
index 32c175f..c2dc141 100644
--- a/ash/ash_strings.grd
+++ b/ash/ash_strings.grd

@@ -2342,6 +2342,11 @@
         Don't show again
       </message>
 
+      <!-- Media Tray  -->
+      <message name="IDS_ASH_GLOBAL_MEDIA_CONTROLS_BUTTON_TOOLTIP_TEXT" desc="Tooltip for the Global Media Controls icon, which appears in the toolbar. The tooltip appears on mouseover of the icon.">
+        Control your music, videos, and more
+      </message>
+
       <!-- Power off menu  -->
       <message name="IDS_ASH_POWER_BUTTON_MENU_POWER_OFF_BUTTON" desc="Text shown on power off button in power button menu.">
         Power off

diff --git a/ash/ash_strings_grd/IDS_ASH_GLOBAL_MEDIA_CONTROLS_BUTTON_TOOLTIP_TEXT.png.sha1 b/ash/ash_strings_grd/IDS_ASH_GLOBAL_MEDIA_CONTROLS_BUTTON_TOOLTIP_TEXT.png.sha1
new file mode 100644
index 0000000..c44b170
--- /dev/null
+++ b/ash/ash_strings_grd/IDS_ASH_GLOBAL_MEDIA_CONTROLS_BUTTON_TOOLTIP_TEXT.png.sha1

@@ -0,0 +1 @@
+e44408d259df841b2444eb2484e3ef7995e18af5
\ No newline at end of file

diff --git a/ash/clipboard/clipboard_history.cc b/ash/clipboard/clipboard_history.cc
index c5f16b0..6ef9b56 100644
--- a/ash/clipboard/clipboard_history.cc
+++ b/ash/clipboard/clipboard_history.cc

@@ -4,7 +4,11 @@
 
 #include "ash/clipboard/clipboard_history.h"
 
+#include "ash/clipboard/clipboard_history_controller.h"
 #include "ash/clipboard/clipboard_history_util.h"
+#include "ash/clipboard/clipboard_nudge_controller.h"
+#include "ash/session/session_controller_impl.h"
+#include "ash/shell.h"
 #include "base/stl_util.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "ui/base/clipboard/clipboard_data_endpoint.h"
@@ -86,6 +90,8 @@
                      commit_data_weak_factory_.GetWeakPtr(), *clipboard_data));
 }
 
+void ClipboardHistory::OnClipboardDataRead() {}
+
 void ClipboardHistory::MaybeCommitData(ui::ClipboardData data) {
   if (!ClipboardHistoryUtil::IsSupported(data))
     return;

diff --git a/ash/clipboard/clipboard_history.h b/ash/clipboard/clipboard_history.h
index 61b1be0c..f6eb388 100644
--- a/ash/clipboard/clipboard_history.h
+++ b/ash/clipboard/clipboard_history.h

@@ -10,6 +10,8 @@
 
 #include "ash/ash_export.h"
 #include "ash/clipboard/clipboard_history_item.h"
+#include "ash/public/cpp/session/session_observer.h"
+#include "ash/shell_observer.h"
 #include "base/component_export.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
@@ -66,6 +68,7 @@
 
   // ClipboardMonitor:
   void OnClipboardDataChanged() override;
+  void OnClipboardDataRead() override;
 
  private:
   // Adds `data` to the `history_list_` if it's supported. If `data` is not

diff --git a/ash/clipboard/clipboard_history_controller.cc b/ash/clipboard/clipboard_history_controller.cc
index 9c0c595..eb16f9d 100644
--- a/ash/clipboard/clipboard_history_controller.cc
+++ b/ash/clipboard/clipboard_history_controller.cc

@@ -113,7 +113,9 @@
       resource_manager_(std::make_unique<ClipboardHistoryResourceManager>(
           clipboard_history_.get())),
       accelerator_target_(std::make_unique<AcceleratorTarget>(this)),
-      menu_delegate_(std::make_unique<MenuDelegate>(this)) {}
+      menu_delegate_(std::make_unique<MenuDelegate>(this)),
+      nudge_controller_(std::make_unique<ClipboardNudgeController>(
+          clipboard_history_.get())) {}
 
 ClipboardHistoryController::~ClipboardHistoryController() = default;
 

diff --git a/ash/clipboard/clipboard_history_controller.h b/ash/clipboard/clipboard_history_controller.h
index 753a604..e397496 100644
--- a/ash/clipboard/clipboard_history_controller.h
+++ b/ash/clipboard/clipboard_history_controller.h

@@ -10,6 +10,7 @@
 
 #include "ash/ash_export.h"
 #include "ash/clipboard/clipboard_history_item.h"
+#include "ash/clipboard/clipboard_nudge_controller.h"
 #include "base/memory/weak_ptr.h"
 
 namespace gfx {
@@ -49,6 +50,10 @@
     return resource_manager_.get();
   }
 
+  ClipboardNudgeController* nudge_controller() const {
+    return nudge_controller_.get();
+  }
+
  private:
   class AcceleratorTarget;
   class MenuDelegate;
@@ -72,6 +77,8 @@
   std::unique_ptr<MenuDelegate> menu_delegate_;
   // The items we show in the contextual menu. Saved so we can paste them later.
   std::vector<ClipboardHistoryItem> clipboard_items_;
+  // Controller that shows contextual nudges for multipaste.
+  std::unique_ptr<ClipboardNudgeController> nudge_controller_;
 
   base::WeakPtrFactory<ClipboardHistoryController> weak_ptr_factory_{this};
 };

diff --git a/ash/clipboard/clipboard_nudge_constants.h b/ash/clipboard/clipboard_nudge_constants.h
new file mode 100644
index 0000000..90e80ea
--- /dev/null
+++ b/ash/clipboard/clipboard_nudge_constants.h

@@ -0,0 +1,19 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef ASH_CLIPBOARD_CLIPBOARD_NUDGE_CONSTANTS_H_
+#define ASH_CLIPBOARD_CLIPBOARD_NUDGE_CONSTANTS_H_
+
+#include "base/time/time.h"
+
+namespace ash {
+
+constexpr static int kNotificationLimit = 3;
+constexpr static base::TimeDelta kMinInterval = base::TimeDelta::FromDays(1);
+constexpr static base::TimeDelta kMaxTimeBetweenPaste =
+    base::TimeDelta::FromMinutes(10);
+
+}  // namespace ash
+
+#endif  // ASH_CLIPBOARD_CLIPBOARD_NUDGE_CONSTANTS_H_

diff --git a/ash/clipboard/clipboard_nudge_controller.cc b/ash/clipboard/clipboard_nudge_controller.cc
new file mode 100644
index 0000000..e2b8dd3
--- /dev/null
+++ b/ash/clipboard/clipboard_nudge_controller.cc

@@ -0,0 +1,161 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ash/clipboard/clipboard_nudge_controller.h"
+
+#include "ash/clipboard/clipboard_history_item.h"
+#include "ash/clipboard/clipboard_nudge_constants.h"
+#include "ash/public/cpp/ash_pref_names.h"
+#include "ash/session/session_controller_impl.h"
+#include "ash/shell.h"
+#include "base/logging.h"
+#include "base/no_destructor.h"
+#include "base/util/values/values_util.h"
+#include "components/prefs/pref_registry_simple.h"
+#include "components/prefs/pref_service.h"
+#include "components/prefs/scoped_user_pref_update.h"
+
+namespace {
+
+// Keys for tooltip sub-preferences for shown count and last time shown.
+constexpr char kShownCount[] = "shown_count";
+constexpr char kLastTimeShown[] = "last_time_shown";
+
+}  // namespace
+
+namespace ash {
+
+ClipboardNudgeController::ClipboardNudgeController(
+    ClipboardHistory* clipboard_history)
+    : clipboard_history_(clipboard_history) {
+  clipboard_history_->AddObserver(this);
+}
+
+ClipboardNudgeController::~ClipboardNudgeController() {
+  clipboard_history_->RemoveObserver(this);
+}
+
+// static
+void ClipboardNudgeController::RegisterProfilePrefs(
+    PrefRegistrySimple* registry) {
+  registry->RegisterDictionaryPref(prefs::kMultipasteNudges);
+}
+
+void ClipboardNudgeController::OnClipboardHistoryItemAdded(
+    const ClipboardHistoryItem& item) {
+  PrefService* prefs =
+      Shell::Get()->session_controller()->GetLastActiveUserPrefService();
+  if (!ShouldShowNudge(prefs))
+    return;
+
+  switch (clipboard_state_) {
+    case ClipboardState::kInit:
+      clipboard_state_ = ClipboardState::kFirstCopy;
+      return;
+    case ClipboardState::kFirstPaste:
+      clipboard_state_ = ClipboardState::kSecondCopy;
+      return;
+    case ClipboardState::kFirstCopy:
+    case ClipboardState::kSecondCopy:
+    case ClipboardState::kShouldShowNudge:
+      return;
+  }
+}
+
+void ClipboardNudgeController::OnClipboardDataChanged() {}
+
+void ClipboardNudgeController::OnClipboardDataRead() {
+  PrefService* prefs =
+      Shell::Get()->session_controller()->GetLastActiveUserPrefService();
+  if (!ShouldShowNudge(prefs))
+    return;
+
+  switch (clipboard_state_) {
+    case ClipboardState::kFirstCopy:
+      clipboard_state_ = ClipboardState::kFirstPaste;
+      last_paste_timestamp_ = GetTime();
+      return;
+    case ClipboardState::kFirstPaste:
+      // Subsequent pastes should reset the timestamp.
+      last_paste_timestamp_ = GetTime();
+      return;
+    case ClipboardState::kSecondCopy:
+      if (GetTime() - last_paste_timestamp_ < kMaxTimeBetweenPaste) {
+        clipboard_state_ = ClipboardState::kShouldShowNudge;
+        // TODO(crbug/1105541): Show clipboard nudge.
+      } else {
+        // ClipboardState should be reset to kFirstPaste when timed out.
+        clipboard_state_ = ClipboardState::kFirstPaste;
+        last_paste_timestamp_ = GetTime();
+      }
+      return;
+    case ClipboardState::kInit:
+    case ClipboardState::kShouldShowNudge:
+      return;
+  }
+}
+
+void ClipboardNudgeController::HandleNudgeShown() {
+  clipboard_state_ = ClipboardState::kInit;
+  PrefService* prefs =
+      Shell::Get()->session_controller()->GetLastActiveUserPrefService();
+  const int shown_count = GetShownCount(prefs);
+  DictionaryPrefUpdate update(prefs, prefs::kMultipasteNudges);
+  update->SetIntPath(kShownCount, shown_count + 1);
+  update->SetPath(kLastTimeShown, util::TimeToValue(GetTime()));
+}
+
+void ClipboardNudgeController::OverrideClockForTesting(
+    base::Clock* test_clock) {
+  DCHECK(!g_clock_override);
+  g_clock_override = test_clock;
+}
+
+void ClipboardNudgeController::ClearClockOverrideForTesting() {
+  DCHECK(g_clock_override);
+  g_clock_override = nullptr;
+}
+
+const ClipboardState& ClipboardNudgeController::GetClipboardStateForTesting() {
+  return clipboard_state_;
+}
+
+int ClipboardNudgeController::GetShownCount(PrefService* prefs) {
+  base::Optional<int> nudge_shown_count =
+      prefs->GetDictionary(prefs::kMultipasteNudges)->FindIntPath(kShownCount);
+  return nudge_shown_count.value_or(0);
+}
+
+base::Time ClipboardNudgeController::GetLastShownTime(PrefService* prefs) {
+  const base::Value* last_shown_time_val =
+      prefs->GetDictionary(prefs::kMultipasteNudges)->FindPath(kLastTimeShown);
+  if (!last_shown_time_val)
+    return base::Time();
+  base::Optional<base::Time> last_shown_time =
+      *util::ValueToTime(last_shown_time_val);
+  return last_shown_time.value_or(base::Time());
+}
+
+bool ClipboardNudgeController::ShouldShowNudge(PrefService* prefs) {
+  int nudge_shown_count = GetShownCount(prefs);
+  base::Time last_shown_time = GetLastShownTime(prefs);
+  // We should not show more nudges after hitting the limit.
+  if (nudge_shown_count >= kNotificationLimit)
+    return false;
+  // If the nudge has yet to be shown, we should return true.
+  if (last_shown_time.is_null())
+    return true;
+
+  // We should show the nudge if enough time has passed since the nudge was last
+  // shown.
+  return base::Time::Now() - last_shown_time > kMinInterval;
+}
+
+base::Time ClipboardNudgeController::GetTime() {
+  if (g_clock_override)
+    return g_clock_override->Now();
+  return base::Time::Now();
+}
+
+}  // namespace ash

diff --git a/ash/clipboard/clipboard_nudge_controller.h b/ash/clipboard/clipboard_nudge_controller.h
new file mode 100644
index 0000000..85c23d8c
--- /dev/null
+++ b/ash/clipboard/clipboard_nudge_controller.h

@@ -0,0 +1,80 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef ASH_CLIPBOARD_CLIPBOARD_NUDGE_CONTROLLER_H_
+#define ASH_CLIPBOARD_CLIPBOARD_NUDGE_CONTROLLER_H_
+
+#include "ash/ash_export.h"
+#include "ash/clipboard/clipboard_history.h"
+#include "base/time/clock.h"
+#include "ui/base/clipboard/clipboard_observer.h"
+
+class PrefService;
+class PrefRegistrySimple;
+class ClipboardHistoryItem;
+
+namespace ash {
+
+// The clipboard contextual nudge will be shown after 4 user actions that must
+// happen in sequence. The user must perform copy, paste, copy and paste in
+// sequence to activate the nudge.
+enum class ClipboardState {
+  kInit = 0,
+  kFirstCopy = 1,
+  kFirstPaste = 2,
+  kSecondCopy = 3,
+  kShouldShowNudge = 4,
+};
+
+class ASH_EXPORT ClipboardNudgeController : public ClipboardHistory::Observer,
+                                            public ui::ClipboardObserver {
+ public:
+  ClipboardNudgeController(ClipboardHistory* clipboard_history);
+  ClipboardNudgeController(const ClipboardNudgeController&) = delete;
+  ClipboardNudgeController& operator=(const ClipboardNudgeController&) = delete;
+  ~ClipboardNudgeController() override;
+
+  // Registers profile prefs.
+  static void RegisterProfilePrefs(PrefRegistrySimple* registry);
+
+  // ui::ClipboardHistoryObserver:
+  void OnClipboardHistoryItemAdded(const ClipboardHistoryItem& item) override;
+
+  // ui::ClipboardObserver:
+  void OnClipboardDataChanged() override;
+  void OnClipboardDataRead() override;
+
+  // Resets nudge state and show nudge timer.
+  void HandleNudgeShown();
+
+  // Test methods for overriding and resetting the clock used by GetTime.
+  void OverrideClockForTesting(base::Clock* test_clock);
+  void ClearClockOverrideForTesting();
+
+  const ClipboardState& GetClipboardStateForTesting();
+
+ private:
+  // Gets the number of times the nudge has been shown.
+  int GetShownCount(PrefService* prefs);
+  // Gets the last time the nudge was shown.
+  base::Time GetLastShownTime(PrefService* prefs);
+  // Checks whether another nudge can be shown.
+  bool ShouldShowNudge(PrefService* prefs);
+  // Gets the current time. Can be overridden for testing.
+  base::Time GetTime();
+
+  // Owned by ClipboardHistoryController.
+  const ClipboardHistory* clipboard_history_;
+
+  // Current clipboard state.
+  ClipboardState clipboard_state_ = ClipboardState::kInit;
+  // The timestamp of the most recent paste.
+  base::Time last_paste_timestamp_;
+  // Clock that can be overridden for testing.
+  base::Clock* g_clock_override = nullptr;
+};
+
+}  // namespace ash
+
+#endif  // ASH_CLIPBOARD_CLIPBOARD_NUDGE_CONTROLLER_H_

diff --git a/ash/clipboard/clipboard_nudge_controller_unittest.cc b/ash/clipboard/clipboard_nudge_controller_unittest.cc
new file mode 100644
index 0000000..63be3868
--- /dev/null
+++ b/ash/clipboard/clipboard_nudge_controller_unittest.cc

@@ -0,0 +1,178 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ash/clipboard/clipboard_nudge_controller.h"
+
+#include "ash/clipboard/clipboard_history.h"
+#include "ash/clipboard/clipboard_history_controller.h"
+#include "ash/clipboard/clipboard_nudge_constants.h"
+#include "ash/session/session_controller_impl.h"
+#include "ash/shell.h"
+#include "ash/test/ash_test_base.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/test/scoped_feature_list.h"
+#include "base/test/simple_test_clock.h"
+#include "chromeos/constants/chromeos_features.h"
+#include "ui/base/clipboard/clipboard_data.h"
+#include "ui/base/clipboard/clipboard_non_backed.h"
+
+namespace ash {
+
+class ClipboardNudgeControllerTest : public AshTestBase {
+ public:
+  ClipboardNudgeControllerTest() = default;
+  ClipboardNudgeControllerTest(const ClipboardNudgeControllerTest&) = delete;
+  ClipboardNudgeControllerTest& operator=(const ClipboardNudgeControllerTest&) =
+      delete;
+  ~ClipboardNudgeControllerTest() override = default;
+
+  base::SimpleTestClock* clock() { return &test_clock_; }
+
+  // AshTestBase:
+  void SetUp() override {
+    scoped_feature_list_.InitAndEnableFeature(
+        chromeos::features::kClipboardHistory);
+    AshTestBase::SetUp();
+    nudge_controller_ =
+        Shell::Get()->clipboard_history_controller()->nudge_controller();
+    nudge_controller_->OverrideClockForTesting(&test_clock_);
+    test_clock_.Advance(base::TimeDelta::FromSeconds(360));
+  }
+
+  void TearDown() override {
+    nudge_controller_->ClearClockOverrideForTesting();
+    AshTestBase::TearDown();
+  }
+
+  // Owned by ClipboardHistoryController.
+  ClipboardNudgeController* nudge_controller_;
+
+ private:
+  base::test::ScopedFeatureList scoped_feature_list_;
+  base::SimpleTestClock test_clock_;
+};
+
+// Checks that clipboard state advances after the nudge controller is fed the
+// right event type.
+TEST_F(ClipboardNudgeControllerTest, ShouldShowNudgeAfterCorrectSequence) {
+  EXPECT_EQ(ClipboardState::kInit,
+            nudge_controller_->GetClipboardStateForTesting());
+  // Checks that the first copy advances state as expected.
+  nudge_controller_->OnClipboardHistoryItemAdded(
+      ClipboardHistoryItem(ui::ClipboardData()));
+  EXPECT_EQ(ClipboardState::kFirstCopy,
+            nudge_controller_->GetClipboardStateForTesting());
+
+  // Checks that the first paste advances state as expected.
+  nudge_controller_->OnClipboardDataRead();
+  EXPECT_EQ(ClipboardState::kFirstPaste,
+            nudge_controller_->GetClipboardStateForTesting());
+
+  // Checks that the second copy advances state as expected.
+  nudge_controller_->OnClipboardHistoryItemAdded(
+      ClipboardHistoryItem(ui::ClipboardData()));
+  EXPECT_EQ(ClipboardState::kSecondCopy,
+            nudge_controller_->GetClipboardStateForTesting());
+
+  // Checks that the second paste advances state as expected.
+  nudge_controller_->OnClipboardDataRead();
+  EXPECT_EQ(ClipboardState::kShouldShowNudge,
+            nudge_controller_->GetClipboardStateForTesting());
+}
+
+// Checks that the clipboard state does not advace if too much time passes
+// during the copy paste sequence.
+TEST_F(ClipboardNudgeControllerTest, NudgeTimeOut) {
+  // Perform copy -> paste -> copy sequence.
+  nudge_controller_->OnClipboardHistoryItemAdded(
+      ClipboardHistoryItem(ui::ClipboardData()));
+  nudge_controller_->OnClipboardDataRead();
+  nudge_controller_->OnClipboardHistoryItemAdded(
+      ClipboardHistoryItem(ui::ClipboardData()));
+
+  // Advance time to cause the nudge timer to time out.
+  clock()->Advance(kMaxTimeBetweenPaste);
+  nudge_controller_->OnClipboardDataRead();
+
+  // Paste event should reset clipboard state to |kFirstPaste| instead of to
+  // |kShouldShowNudge|.
+  EXPECT_NE(ClipboardState::kShouldShowNudge,
+            nudge_controller_->GetClipboardStateForTesting());
+  EXPECT_EQ(ClipboardState::kFirstPaste,
+            nudge_controller_->GetClipboardStateForTesting());
+}
+
+// Checks that multiple pastes refreshes the |kMaxTimeBetweenPaste| timer that
+// determines whether too much time has passed to show the nudge.
+TEST_F(ClipboardNudgeControllerTest, NudgeDoesNotTimeOutWithSparsePastes) {
+  nudge_controller_->OnClipboardHistoryItemAdded(
+      ClipboardHistoryItem(ui::ClipboardData()));
+  nudge_controller_->OnClipboardDataRead();
+  EXPECT_EQ(ClipboardState::kFirstPaste,
+            nudge_controller_->GetClipboardStateForTesting());
+
+  // Perform 5 pastes over 2.5*|kMaxTimeBetweenPaste|.
+  for (int paste_cycle = 0; paste_cycle < 5; paste_cycle++) {
+    SCOPED_TRACE("paste cycle " + base::NumberToString(paste_cycle));
+    clock()->Advance(kMaxTimeBetweenPaste / 2);
+    nudge_controller_->OnClipboardDataRead();
+    EXPECT_EQ(ClipboardState::kFirstPaste,
+              nudge_controller_->GetClipboardStateForTesting());
+  }
+
+  // Check that HandleClipboardChanged() will advance nudge_controller's
+  // ClipboardState.
+  nudge_controller_->OnClipboardHistoryItemAdded(
+      ClipboardHistoryItem(ui::ClipboardData()));
+  EXPECT_EQ(ClipboardState::kSecondCopy,
+            nudge_controller_->GetClipboardStateForTesting());
+  nudge_controller_->OnClipboardDataRead();
+  EXPECT_EQ(ClipboardState::kShouldShowNudge,
+            nudge_controller_->GetClipboardStateForTesting());
+}
+
+// Checks that consecutive copy events does not advance the clipboard state.
+TEST_F(ClipboardNudgeControllerTest, RepeatedCopyDoesNotAdvanceState) {
+  nudge_controller_->OnClipboardHistoryItemAdded(
+      ClipboardHistoryItem(ui::ClipboardData()));
+  EXPECT_EQ(ClipboardState::kFirstCopy,
+            nudge_controller_->GetClipboardStateForTesting());
+  nudge_controller_->OnClipboardHistoryItemAdded(
+      ClipboardHistoryItem(ui::ClipboardData()));
+  EXPECT_EQ(ClipboardState::kFirstCopy,
+            nudge_controller_->GetClipboardStateForTesting());
+}
+
+// Checks that consecutive paste events does not advance the clipboard state.
+TEST_F(ClipboardNudgeControllerTest, RepeatedPasteDoesNotAdvanceState) {
+  nudge_controller_->OnClipboardHistoryItemAdded(
+      ClipboardHistoryItem(ui::ClipboardData()));
+  EXPECT_EQ(ClipboardState::kFirstCopy,
+            nudge_controller_->GetClipboardStateForTesting());
+  nudge_controller_->OnClipboardDataRead();
+  EXPECT_EQ(ClipboardState::kFirstPaste,
+            nudge_controller_->GetClipboardStateForTesting());
+  nudge_controller_->OnClipboardDataRead();
+  EXPECT_EQ(ClipboardState::kFirstPaste,
+            nudge_controller_->GetClipboardStateForTesting());
+}
+
+// Verifies that administrative events does not advance clipboard state.
+TEST_F(ClipboardNudgeControllerTest, AdminWriteDoesNotAdvanceState) {
+  nudge_controller_->OnClipboardHistoryItemAdded(
+      ClipboardHistoryItem(ui::ClipboardData()));
+  nudge_controller_->OnClipboardDataRead();
+  EXPECT_EQ(ClipboardState::kFirstPaste,
+            nudge_controller_->GetClipboardStateForTesting());
+
+  auto data = std::make_unique<ui::ClipboardData>();
+  data->set_text("test");
+  // Write the data to the clipboard, clipboard state should not advance.
+  ui::ClipboardNonBacked::GetForCurrentThread()->WriteClipboardData(
+      std::move(data));
+  EXPECT_EQ(ClipboardState::kFirstPaste,
+            nudge_controller_->GetClipboardStateForTesting());
+}
+
+}  // namespace ash

diff --git a/ash/public/cpp/ash_pref_names.cc b/ash/public/cpp/ash_pref_names.cc
index a71d7cb..0e64eee 100644
--- a/ash/public/cpp/ash_pref_names.cc
+++ b/ash/public/cpp/ash_pref_names.cc

@@ -573,6 +573,10 @@
 // A boolean pref which is true if mouse reverse scroll is enabled.
 const char kMouseReverseScroll[] = "settings.mouse.reverse_scroll";
 
+// A dictionary storing the number of times and most recent time the multipaste
+// contextual nudge was shown.
+const char kMultipasteNudges[] = "ash.clipboard.multipaste_nudges";
+
 // NOTE: New prefs should start with the "ash." prefix. Existing prefs moved
 // into this file should not be renamed, since they may be synced.
 

diff --git a/ash/public/cpp/ash_pref_names.h b/ash/public/cpp/ash_pref_names.h
index 18053ae..1b167a57 100644
--- a/ash/public/cpp/ash_pref_names.h
+++ b/ash/public/cpp/ash_pref_names.h

@@ -205,6 +205,8 @@
 ASH_PUBLIC_EXPORT extern const char kNaturalScroll[];
 ASH_PUBLIC_EXPORT extern const char kMouseReverseScroll[];
 
+ASH_PUBLIC_EXPORT extern const char kMultipasteNudges[];
+
 }  // namespace prefs
 
 }  // namespace ash

diff --git a/ash/resources/vector_icons/BUILD.gn b/ash/resources/vector_icons/BUILD.gn
index 44edae3..d5dcc88 100644
--- a/ash/resources/vector_icons/BUILD.gn
+++ b/ash/resources/vector_icons/BUILD.gn

@@ -49,6 +49,7 @@
     "dictation_on.icon",
     "dictation_on_newui.icon",
     "dogfood.icon",
+    "global_media_controls.icon",
     "hollow_check_circle.icon",
     "html.icon",
     "ime_menu_emoticon.icon",

diff --git a/ash/resources/vector_icons/global_media_controls.icon b/ash/resources/vector_icons/global_media_controls.icon
new file mode 100644
index 0000000..a45953f
--- /dev/null
+++ b/ash/resources/vector_icons/global_media_controls.icon

@@ -0,0 +1,41 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+CANVAS_DIMENSIONS, 16,
+MOVE_TO, 15.25f, 2,
+R_CUBIC_TO, 0.41f, 0, 0.75f, 0.34f, 0.75f, 0.75f,
+R_CUBIC_TO, 0, 0.41f, -0.34f, 0.75f, -0.75f, 0.75f,
+H_LINE_TO, 13.5f,
+R_LINE_TO, 0, 7.98f,
+CUBIC_TO, 13.47f, 12.99f, 12.38f, 14, 11, 14,
+R_CUBIC_TO, -1.38f, 0, -2.5f, -1.12f, -2.5f, -2.5f,
+CUBIC_TO, 8.5f, 10.12f, 9.62f, 9, 11, 9,
+R_CUBIC_TO, 0.36f, 0, 0.69f, 0.07f, 1, 0.21f,
+LINE_TO, 12, 2.75f,
+R_CUBIC_TO, 0, -0.41f, 0.34f, -0.75f, 0.75f, -0.75f,
+R_H_LINE_TO, 2.5f,
+CLOSE,
+MOVE_TO, 6.89f, 10,
+CUBIC_TO, 6.64f, 10.45f, 6.5f, 10.96f, 6.5f, 11.5f,
+H_LINE_TO, 0.75f,
+CUBIC_TO, 0.34f, 11.5f, 0, 11.16f, 0, 10.75f,
+CUBIC_TO_SHORTHAND, 0.34f, 10, 0.75f, 10,
+R_LINE_TO, 6.14f, 0,
+CLOSE,
+MOVE_TO, 9.25f, 6,
+R_CUBIC_TO, 0.41f, 0, 0.75f, 0.34f, 0.75f, 0.75f,
+R_CUBIC_TO, 0, 0.41f, -0.34f, 0.75f, -0.75f, 0.75f,
+H_LINE_TO, 0.75f,
+CUBIC_TO, 0.34f, 7.5f, 0, 7.16f, 0, 6.75f,
+CUBIC_TO_SHORTHAND, 0.34f, 6, 0.75f, 6,
+R_H_LINE_TO, 8.5f,
+CLOSE,
+R_MOVE_TO, 0, -4,
+R_CUBIC_TO, 0.41f, 0, 0.75f, 0.34f, 0.75f, 0.75f,
+R_CUBIC_TO, 0, 0.41f, -0.34f, 0.75f, -0.75f, 0.75f,
+H_LINE_TO, 0.75f,
+CUBIC_TO, 0.34f, 3.5f, 0, 3.16f, 0, 2.75f,
+CUBIC_TO_SHORTHAND, 0.34f, 2, 0.75f, 2,
+R_H_LINE_TO, 8.5f,
+CLOSE

diff --git a/ash/system/media/media_tray.cc b/ash/system/media/media_tray.cc
new file mode 100644
index 0000000..cec5af2c
--- /dev/null
+++ b/ash/system/media/media_tray.cc

@@ -0,0 +1,72 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ash/system/media/media_tray.h"
+
+#include "ash/public/cpp/media_notification_provider.h"
+#include "ash/resources/vector_icons/vector_icons.h"
+#include "ash/session/session_controller_impl.h"
+#include "ash/shell.h"
+#include "ash/strings/grit/ash_strings.h"
+#include "ash/system/tray/tray_constants.h"
+#include "ash/system/tray/tray_container.h"
+#include "ash/system/tray/tray_utils.h"
+#include "base/strings/string_util.h"
+#include "ui/base/l10n/l10n_util.h"
+#include "ui/gfx/paint_vector_icon.h"
+#include "ui/views/controls/image_view.h"
+
+namespace ash {
+
+MediaTray::MediaTray(Shelf* shelf) : TrayBackgroundView(shelf) {
+  DCHECK(MediaNotificationProvider::Get());
+  MediaNotificationProvider::Get()->AddObserver(this);
+
+  auto icon = std::make_unique<views::ImageView>();
+  icon->set_tooltip_text(l10n_util::GetStringUTF16(
+      IDS_ASH_GLOBAL_MEDIA_CONTROLS_BUTTON_TOOLTIP_TEXT));
+  icon->SetImage(gfx::CreateVectorIcon(
+      kGlobalMediaControlsIcon,
+      TrayIconColor(Shell::Get()->session_controller()->GetSessionState())));
+
+  tray_container()->SetMargin(kMediaTrayPadding, 0);
+  icon_ = tray_container()->AddChildView(std::move(icon));
+}
+
+MediaTray::~MediaTray() {
+  if (MediaNotificationProvider::Get())
+    MediaNotificationProvider::Get()->RemoveObserver(this);
+}
+
+void MediaTray::OnNotificationListChanged() {
+  UpdateDisplayState();
+}
+
+void MediaTray::OnNotificationListViewSizeChanged() {}
+
+base::string16 MediaTray::GetAccessibleNameForTray() {
+  return l10n_util::GetStringUTF16(
+      IDS_ASH_GLOBAL_MEDIA_CONTROLS_BUTTON_TOOLTIP_TEXT);
+}
+
+void MediaTray::UpdateAfterLoginStatusChange() {
+  UpdateDisplayState();
+  PreferredSizeChanged();
+}
+
+void MediaTray::HandleLocaleChange() {
+  icon_->set_tooltip_text(l10n_util::GetStringUTF16(
+      IDS_ASH_GLOBAL_MEDIA_CONTROLS_BUTTON_TOOLTIP_TEXT));
+}
+
+void MediaTray::UpdateDisplayState() {
+  if (!MediaNotificationProvider::Get())
+    return;
+
+  SetVisiblePreferred(
+      MediaNotificationProvider::Get()->HasActiveNotifications() ||
+      MediaNotificationProvider::Get()->HasFrozenNotifications());
+}
+
+}  // namespace ash

diff --git a/ash/system/media/media_tray.h b/ash/system/media/media_tray.h
new file mode 100644
index 0000000..647292d
--- /dev/null
+++ b/ash/system/media/media_tray.h

@@ -0,0 +1,45 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef ASH_SYSTEM_MEDIA_MEDIA_TRAY_H_
+#define ASH_SYSTEM_MEDIA_MEDIA_TRAY_H_
+
+#include "ash/public/cpp/media_notification_provider_observer.h"
+#include "ash/system/tray/tray_background_view.h"
+
+namespace views {
+class ImageView;
+}  // namespace views
+
+namespace ash {
+
+class Shelf;
+
+class MediaTray : public MediaNotificationProviderObserver,
+                  public TrayBackgroundView {
+ public:
+  explicit MediaTray(Shelf* shelf);
+  ~MediaTray() override;
+
+  // MediaNotificationProviderObserver implementations.
+  void OnNotificationListChanged() override;
+  void OnNotificationListViewSizeChanged() override;
+
+  // TrayBackgroundview implementations.
+  base::string16 GetAccessibleNameForTray() override;
+  void UpdateAfterLoginStatusChange() override;
+  void HandleLocaleChange() override;
+  void HideBubbleWithView(const TrayBubbleView* bubble_view) override {}
+  void ClickedOutsideBubble() override {}
+
+ private:
+  void UpdateDisplayState();
+
+  // Weak pointer, will be parented by TrayContainer for its lifetime.
+  views::ImageView* icon_;
+};
+
+}  // namespace ash
+
+#endif  // ASH_SYSTEM_MEDIA_MEDIA_TRAY_H_

diff --git a/ash/system/status_area_widget.cc b/ash/system/status_area_widget.cc
index 495b165..681edd6 100644
--- a/ash/system/status_area_widget.cc
+++ b/ash/system/status_area_widget.cc

@@ -18,6 +18,7 @@
 #include "ash/system/accessibility/select_to_speak_tray.h"
 #include "ash/system/holding_space/holding_space_tray.h"
 #include "ash/system/ime_menu/ime_menu_tray.h"
+#include "ash/system/media/media_tray.h"
 #include "ash/system/overview/overview_button_tray.h"
 #include "ash/system/palette/palette_tray.h"
 #include "ash/system/session/logout_button_tray.h"
@@ -33,6 +34,7 @@
 #include "base/i18n/time_formatting.h"
 #include "base/metrics/histogram_macros.h"
 #include "chromeos/constants/chromeos_switches.h"
+#include "media/base/media_switches.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/display/display.h"
 
@@ -114,6 +116,11 @@
   palette_tray_ = std::make_unique<PaletteTray>(shelf_);
   AddTrayButton(palette_tray_.get());
 
+  if (base::FeatureList::IsEnabled(media::kGlobalMediaControlsForChromeOS)) {
+    media_tray_ = std::make_unique<MediaTray>(shelf_);
+    AddTrayButton(media_tray_.get());
+  }
+
   unified_system_tray_ = std::make_unique<UnifiedSystemTray>(shelf_);
   AddTrayButton(unified_system_tray_.get());
 

diff --git a/ash/system/status_area_widget.h b/ash/system/status_area_widget.h
index 92b4f58..712b5fd 100644
--- a/ash/system/status_area_widget.h
+++ b/ash/system/status_area_widget.h

@@ -33,6 +33,7 @@
 class UnifiedSystemTray;
 class TrayBackgroundView;
 class VirtualKeyboardTray;
+class MediaTray;
 
 // Widget showing the system tray, notification tray, and other tray views in
 // the bottom-right of the screen. Exists separately from ShelfView/ShelfWidget
@@ -212,6 +213,7 @@
   std::unique_ptr<StatusAreaOverflowButtonTray> overflow_button_tray_;
   std::unique_ptr<OverviewButtonTray> overview_button_tray_;
   std::unique_ptr<DictationButtonTray> dictation_button_tray_;
+  std::unique_ptr<MediaTray> media_tray_;
   std::unique_ptr<UnifiedSystemTray> unified_system_tray_;
   std::unique_ptr<LogoutButtonTray> logout_button_tray_;
   std::unique_ptr<PaletteTray> palette_tray_;

diff --git a/ash/system/tray/tray_constants.h b/ash/system/tray/tray_constants.h
index b57458b..0a4454c 100644
--- a/ash/system/tray/tray_constants.h
+++ b/ash/system/tray/tray_constants.h

@@ -238,6 +238,9 @@
 constexpr gfx::Insets kHoldingSpaceContainerPadding = gfx::Insets(16);
 constexpr int kHoldingSpaceContainerSeparation = 8;
 
+// Constants used for media tray.
+constexpr int kMediaTrayPadding = 8;
+
 }  // namespace ash
 
 #endif  // ASH_SYSTEM_TRAY_TRAY_CONSTANTS_H_

diff --git a/ash/wm/window_cycle_controller.cc b/ash/wm/window_cycle_controller.cc
index 9913b659..3f99cbc0 100644
--- a/ash/wm/window_cycle_controller.cc
+++ b/ash/wm/window_cycle_controller.cc

@@ -129,7 +129,7 @@
   window_cycle_list_->StepToWindow(window);
 }
 
-bool WindowCycleController::IsEventInCycleView(ui::MouseEvent* event) {
+bool WindowCycleController::IsEventInCycleView(ui::LocatedEvent* event) {
   return window_cycle_list_ && window_cycle_list_->IsEventInCycleView(event);
 }
 

diff --git a/ash/wm/window_cycle_controller.h b/ash/wm/window_cycle_controller.h
index 5d3e2f6..7512a36 100644
--- a/ash/wm/window_cycle_controller.h
+++ b/ash/wm/window_cycle_controller.h

@@ -17,7 +17,7 @@
 }
 
 namespace ui {
-class MouseEvent;
+class LocatedEvent;
 }
 
 namespace ash {
@@ -64,7 +64,7 @@
   void StepToWindow(aura::Window* window);
 
   // Checks whether |event| occurs within the cycle view.
-  bool IsEventInCycleView(ui::MouseEvent* event);
+  bool IsEventInCycleView(ui::LocatedEvent* event);
 
   // Returns the WindowCycleList.
   const WindowCycleList* window_cycle_list() const {

diff --git a/ash/wm/window_cycle_controller_unittest.cc b/ash/wm/window_cycle_controller_unittest.cc
index 31b7b3a..ac9a640616 100644
--- a/ash/wm/window_cycle_controller_unittest.cc
+++ b/ash/wm/window_cycle_controller_unittest.cc

@@ -973,6 +973,30 @@
   EXPECT_TRUE(wm::IsActiveWindow(w1.get()));
 }
 
+// When a user taps on an item, it should cycle to it, complete cycling and
+// activate the tapped item.
+TEST_F(InteractiveWindowCycleControllerTest, TapSelect) {
+  std::unique_ptr<Window> w0 = CreateTestWindow();
+  std::unique_ptr<Window> w1 = CreateTestWindow();
+  std::unique_ptr<Window> w2 = CreateTestWindow();
+  ui::test::EventGenerator* generator = GetEventGenerator();
+  WindowCycleController* controller = Shell::Get()->window_cycle_controller();
+
+  // Start cycle and tap third item.
+  // Starting order of windows in cycle list is [2,1,0].
+  controller->StartCycling();
+  generator->GestureTapAt(
+      GetWindowCycleItemViews()[2]->GetBoundsInScreen().CenterPoint());
+  EXPECT_TRUE(wm::IsActiveWindow(w0.get()));
+
+  // Start cycle and tap second item.
+  // Starting order of windows in cycle list is [0,2,1].
+  controller->StartCycling();
+  generator->GestureTapAt(
+      GetWindowCycleItemViews()[1]->GetBoundsInScreen().CenterPoint());
+  EXPECT_TRUE(wm::IsActiveWindow(w2.get()));
+}
+
 // Tests that frame throttling starts and ends accordingly when window cycling
 // starts and ends.
 TEST_F(WindowCycleControllerTest, FrameThrottling) {

diff --git a/ash/wm/window_cycle_event_filter.cc b/ash/wm/window_cycle_event_filter.cc
index 8080d1b..045896d 100644
--- a/ash/wm/window_cycle_event_filter.cc
+++ b/ash/wm/window_cycle_event_filter.cc

@@ -117,6 +117,25 @@
   }
 }
 
+void WindowCycleEventFilter::OnGestureEvent(ui::GestureEvent* event) {
+  if (features::IsInteractiveWindowCycleListEnabled() &&
+      Shell::Get()->window_cycle_controller()->IsEventInCycleView(event)) {
+    return;
+  }
+
+  // Prevent any form of tap from doing anything while the Alt+Tab UI is active.
+  if (event->type() == ui::ET_GESTURE_TAP ||
+      event->type() == ui::ET_GESTURE_DOUBLE_TAP ||
+      event->type() == ui::ET_GESTURE_TAP_CANCEL ||
+      event->type() == ui::ET_GESTURE_TAP_DOWN ||
+      event->type() == ui::ET_GESTURE_TAP_UNCONFIRMED ||
+      event->type() == ui::ET_GESTURE_TWO_FINGER_TAP ||
+      event->type() == ui::ET_GESTURE_LONG_PRESS ||
+      event->type() == ui::ET_GESTURE_LONG_TAP) {
+    event->StopPropagation();
+  }
+}
+
 WindowCycleEventFilter::AltReleaseHandler::AltReleaseHandler() = default;
 
 WindowCycleEventFilter::AltReleaseHandler::~AltReleaseHandler() = default;

diff --git a/ash/wm/window_cycle_event_filter.h b/ash/wm/window_cycle_event_filter.h
index ea45f49a..48f5954 100644
--- a/ash/wm/window_cycle_event_filter.h
+++ b/ash/wm/window_cycle_event_filter.h

@@ -24,6 +24,7 @@
   // Overridden from ui::EventHandler:
   void OnKeyEvent(ui::KeyEvent* event) override;
   void OnMouseEvent(ui::MouseEvent* event) override;
+  void OnGestureEvent(ui::GestureEvent* event) override;
 
  private:
   class AltReleaseHandler : public ui::EventHandler {

diff --git a/ash/wm/window_cycle_list.cc b/ash/wm/window_cycle_list.cc
index 204872f..f47e820 100644
--- a/ash/wm/window_cycle_list.cc
+++ b/ash/wm/window_cycle_list.cc

@@ -11,6 +11,7 @@
 #include "ash/accessibility/accessibility_controller_impl.h"
 #include "ash/app_list/app_list_controller_impl.h"
 #include "ash/frame_throttler/frame_throttling_controller.h"
+#include "ash/public/cpp/ash_features.h"
 #include "ash/public/cpp/metrics_util.h"
 #include "ash/public/cpp/shell_window_ids.h"
 #include "ash/public/cpp/window_properties.h"
@@ -38,6 +39,7 @@
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_delegate.h"
 #include "ui/wm/core/window_animations.h"
+#include "ui/wm/core/coordinate_conversion.h"
 
 namespace ash {
 
@@ -147,6 +149,23 @@
     return true;
   }
 
+  void OnGestureEvent(ui::GestureEvent* event) override {
+    switch (event->type()) {
+      case ui::ET_GESTURE_TAP:
+      case ui::ET_GESTURE_LONG_PRESS:
+      case ui::ET_GESTURE_LONG_TAP:
+      case ui::ET_GESTURE_TWO_FINGER_TAP: {
+        WindowCycleController* controller =
+            Shell::Get()->window_cycle_controller();
+        controller->StepToWindow(source_window());
+        controller->CompleteCycling();
+        break;
+      }
+      default:
+        break;
+    }
+  }
+
  private:
   // WindowMiniView:
   gfx::Size GetPreviewViewSize() const override {
@@ -545,9 +564,12 @@
   Step(target_index - current_index_);
 }
 
-bool WindowCycleList::IsEventInCycleView(ui::MouseEvent* event) {
-  return cycle_view_->GetBoundsInScreen().Contains(
-      display::Screen::GetScreen()->GetCursorScreenPoint());
+bool WindowCycleList::IsEventInCycleView(ui::LocatedEvent* event) {
+  aura::Window* target = static_cast<aura::Window*>(event->target());
+  aura::Window* event_root = target->GetRootWindow();
+  gfx::Point event_screen_point = event->root_location();
+  wm::ConvertPointToScreen(event_root, &event_screen_point);
+  return cycle_view_->GetBoundsInScreen().Contains(event_screen_point);
 }
 
 // static

diff --git a/ash/wm/window_cycle_list.h b/ash/wm/window_cycle_list.h
index d24a23c..effc6ca 100644
--- a/ash/wm/window_cycle_list.h
+++ b/ash/wm/window_cycle_list.h

@@ -49,7 +49,7 @@
   void StepToWindow(aura::Window* window);
 
   // Checks whether |event| occurs within the cycle view.
-  bool IsEventInCycleView(ui::MouseEvent* event);
+  bool IsEventInCycleView(ui::LocatedEvent* event);
 
   void set_user_did_accept(bool user_did_accept) {
     user_did_accept_ = user_did_accept;

diff --git a/base/metrics/histogram_base.cc b/base/metrics/histogram_base.cc
index ce7fbf16..2b006d02 100644
--- a/base/metrics/histogram_base.cc
+++ b/base/metrics/histogram_base.cc

@@ -176,7 +176,7 @@
   StatisticsRecorder::OnSampleCallback cb =
       StatisticsRecorder::FindCallback(histogram_name());
   if (!cb.is_null())
-    cb.Run(sample);
+    cb.Run(histogram_name(), name_hash(), sample);
 }
 
 void HistogramBase::GetCountAndBucketData(Count* count,

diff --git a/base/metrics/statistics_recorder.h b/base/metrics/statistics_recorder.h
index f7e6719..ecace07e 100644
--- a/base/metrics/statistics_recorder.h
+++ b/base/metrics/statistics_recorder.h

@@ -143,7 +143,10 @@
                             HistogramBase::Flags required_flags,
                             HistogramSnapshotManager* snapshot_manager);
 
-  using OnSampleCallback = base::RepeatingCallback<void(HistogramBase::Sample)>;
+  using OnSampleCallback =
+      base::RepeatingCallback<void(const char* /*=histogram_name*/,
+                                   uint64_t /*=name_hash*/,
+                                   HistogramBase::Sample)>;
 
   // Sets the callback to notify when a new sample is recorded on the histogram
   // referred to by |histogram_name|. Can be called before or after the

diff --git a/base/metrics/statistics_recorder_unittest.cc b/base/metrics/statistics_recorder_unittest.cc
index b2a5450e8..b191dad 100644
--- a/base/metrics/statistics_recorder_unittest.cc
+++ b/base/metrics/statistics_recorder_unittest.cc

@@ -16,6 +16,7 @@
 #include "base/memory/weak_ptr.h"
 #include "base/metrics/histogram_base.h"
 #include "base/metrics/histogram_macros.h"
+#include "base/metrics/metrics_hashes.h"
 #include "base/metrics/persistent_histogram_allocator.h"
 #include "base/metrics/record_histogram_checker.h"
 #include "base/metrics/sparse_histogram.h"
@@ -435,14 +436,24 @@
 // CallbackCheckWrapper is simply a convenient way to check and store that
 // a callback was actually run.
 struct CallbackCheckWrapper {
-  CallbackCheckWrapper() : called(false), last_histogram_value(0) {}
+  CallbackCheckWrapper()
+      : called(false),
+        last_histogram_name(""),
+        last_name_hash(HashMetricName("")),
+        last_histogram_value(0) {}
 
-  void OnHistogramChanged(base::HistogramBase::Sample histogram_value) {
+  void OnHistogramChanged(const char* histogram_name,
+                          uint64_t name_hash,
+                          base::HistogramBase::Sample histogram_value) {
     called = true;
+    last_histogram_name = histogram_name;
+    last_name_hash = name_hash;
     last_histogram_value = histogram_value;
   }
 
   bool called;
+  const char* last_histogram_name;
+  uint64_t last_name_hash;
   base::HistogramBase::Sample last_histogram_value;
 };
 
@@ -535,6 +546,8 @@
     histogram->Add(1);
 
     EXPECT_TRUE(callback_wrapper.called);
+    EXPECT_STREQ(callback_wrapper.last_histogram_name, "TestHistogram");
+    EXPECT_EQ(callback_wrapper.last_name_hash, HashMetricName("TestHistogram"));
     EXPECT_EQ(callback_wrapper.last_histogram_value, 1);
   }
 
@@ -552,6 +565,9 @@
     linear_histogram->Add(1);
 
     EXPECT_TRUE(callback_wrapper.called);
+    EXPECT_STREQ(callback_wrapper.last_histogram_name, "TestLinearHistogram");
+    EXPECT_EQ(callback_wrapper.last_name_hash,
+              HashMetricName("TestLinearHistogram"));
     EXPECT_EQ(callback_wrapper.last_histogram_value, 1);
   }
 
@@ -572,6 +588,9 @@
     custom_histogram->Add(1);
 
     EXPECT_TRUE(callback_wrapper.called);
+    EXPECT_STREQ(callback_wrapper.last_histogram_name, "TestCustomHistogram");
+    EXPECT_EQ(callback_wrapper.last_name_hash,
+              HashMetricName("TestCustomHistogram"));
     EXPECT_EQ(callback_wrapper.last_histogram_value, 1);
   }
 
@@ -589,6 +608,9 @@
     custom_histogram->Add(1);
 
     EXPECT_TRUE(callback_wrapper.called);
+    EXPECT_STREQ(callback_wrapper.last_histogram_name, "TestSparseHistogram");
+    EXPECT_EQ(callback_wrapper.last_name_hash,
+              HashMetricName("TestSparseHistogram"));
     EXPECT_EQ(callback_wrapper.last_histogram_value, 1);
   }
 }
@@ -608,6 +630,8 @@
   histogram->Add(1);
 
   EXPECT_TRUE(callback_wrapper.called);
+  EXPECT_STREQ(callback_wrapper.last_histogram_name, "TestHistogram");
+  EXPECT_EQ(callback_wrapper.last_name_hash, HashMetricName("TestHistogram"));
   EXPECT_EQ(callback_wrapper.last_histogram_value, 1);
 }
 

diff --git a/base/process/memory_unittest.cc b/base/process/memory_unittest.cc
index 43b626f..59eb710 100644
--- a/base/process/memory_unittest.cc
+++ b/base/process/memory_unittest.cc

@@ -435,20 +435,6 @@
   });
 }
 
-#if !defined(ARCH_CPU_64_BITS)
-
-// See process_util_unittest_mac.mm for an explanation of why this test isn't
-// run in the 64-bit environment.
-
-TEST_F(OutOfMemoryDeathTest, PsychoticallyBigObjCObject) {
-  ASSERT_OOM_DEATH({
-    SetUpInDeathAssert();
-    while ((value_ = base::AllocatePsychoticallyBigObjCObject())) {
-    }
-  });
-}
-
-#endif  // !ARCH_CPU_64_BITS
 #endif  // OS_MAC
 
 class OutOfMemoryHandledTest : public OutOfMemoryTest {

diff --git a/base/process/memory_unittest_mac.h b/base/process/memory_unittest_mac.h
index 713589b..8806d7ed 100644
--- a/base/process/memory_unittest_mac.h
+++ b/base/process/memory_unittest_mac.h

@@ -21,15 +21,6 @@
 void* AllocateViaCFAllocatorMalloc(ssize_t size);
 void* AllocateViaCFAllocatorMallocZone(ssize_t size);
 
-#if !defined(ARCH_CPU_64_BITS)
-// See process_util_unittest_mac.mm for an explanation of why this function
-// isn't implemented for the 64-bit environment.
-
-// Allocates a huge Objective C object.
-void* AllocatePsychoticallyBigObjCObject();
-
-#endif  // !ARCH_CPU_64_BITS
-
 }  // namespace base
 
 #endif  // BASE_PROCESS_MEMORY_UNITTEST_MAC_H_

diff --git a/base/process/memory_unittest_mac.mm b/base/process/memory_unittest_mac.mm
index 26fe1af4..7732e66 100644
--- a/base/process/memory_unittest_mac.mm
+++ b/base/process/memory_unittest_mac.mm

@@ -3,46 +3,9 @@
 // found in the LICENSE file.
 
 #include "base/process/memory_unittest_mac.h"
-#include "build/build_config.h"
 
-#import <Foundation/Foundation.h>
 #include <CoreFoundation/CoreFoundation.h>
 
-#if !defined(ARCH_CPU_64_BITS)
-
-// In the 64-bit environment, the Objective-C 2.0 Runtime Reference states
-// that sizeof(anInstance) is constrained to 32 bits. That's not necessarily
-// "psychotically big" and in fact a 64-bit program is expected to be able to
-// successfully allocate an object that large, likely reserving a good deal of
-// swap space. The only way to test the behavior of memory exhaustion for
-// Objective-C allocation in this environment would be to loop over allocation
-// of these large objects, but that would slowly consume all available memory
-// and cause swap file proliferation. That's bad, so this behavior isn't
-// tested in the 64-bit environment.
-
-@interface PsychoticallyBigObjCObject : NSObject
-{
-  // In the 32-bit environment, the compiler limits Objective-C objects to
-  // < 2GB in size.
-  int justUnder2Gigs_[(2U * 1024 * 1024 * 1024 - 1) / sizeof(int)];
-}
-
-@end
-
-@implementation PsychoticallyBigObjCObject
-
-@end
-
-namespace base {
-
-void* AllocatePsychoticallyBigObjCObject() {
-  return [[PsychoticallyBigObjCObject alloc] init];
-}
-
-}  // namespace base
-
-#endif  // ARCH_CPU_64_BITS
-
 namespace base {
 
 void* AllocateViaCFAllocatorSystemDefault(ssize_t size) {

diff --git a/build/android/pylib/local/device/local_device_instrumentation_test_run.py b/build/android/pylib/local/device/local_device_instrumentation_test_run.py
index a37e256..1a24559 100644
--- a/build/android/pylib/local/device/local_device_instrumentation_test_run.py
+++ b/build/android/pylib/local/device/local_device_instrumentation_test_run.py

@@ -591,8 +591,10 @@
                                wpr_archive_path,
                                os.path.exists(wpr_archive_path)))
 
-      archive_path = os.path.join(wpr_archive_path,
-                                  self._GetUniqueTestName(test) + '.wprgo')
+      # Some linux version does not like # in the name. Replaces it with __.
+      archive_path = os.path.join(
+          wpr_archive_path,
+          _ReplaceUncommonChars(self._GetUniqueTestName(test)) + '.wprgo')
 
       if not os.path.exists(_WPR_GO_LINUX_X86_64_PATH):
         # If we got to this stage, then we should have
@@ -636,6 +638,7 @@
       if self._env.trace_output:
         self._SaveTraceData(trace_device_file, device, test['class'])
 
+
       def restore_flags():
         if flags_to_add:
           self._flag_changers[str(device)].Restore()
@@ -1181,6 +1184,17 @@
                                  {}).get('value', ())
 
 
+def _ReplaceUncommonChars(original):
+  """Replaces uncommon characters with __."""
+  if not original:
+    raise ValueError('parameter should not be empty')
+
+  uncommon_chars = ['#']
+  for char in uncommon_chars:
+    original = original.replace(char, '__')
+  return original
+
+
 def _IsRenderTest(test):
   """Determines if a test or list of tests has a RenderTest amongst them."""
   if not isinstance(test, list):

diff --git a/build/android/pylib/local/device/local_device_instrumentation_test_run_test.py b/build/android/pylib/local/device/local_device_instrumentation_test_run_test.py
index dd57d92..1aa8363 100755
--- a/build/android/pylib/local/device/local_device_instrumentation_test_run_test.py
+++ b/build/android/pylib/local/device/local_device_instrumentation_test_run_test.py

@@ -143,6 +143,26 @@
     }
     self.assertFalse(local_device_instrumentation_test_run._IsRenderTest(test))
 
+  def testReplaceUncommonChars(self):
+    original = 'abc#edf'
+    self.assertEqual(
+        local_device_instrumentation_test_run._ReplaceUncommonChars(original),
+        'abc__edf')
+    original = 'abc#edf#hhf'
+    self.assertEqual(
+        local_device_instrumentation_test_run._ReplaceUncommonChars(original),
+        'abc__edf__hhf')
+    original = 'abcedfhhf'
+    self.assertEqual(
+        local_device_instrumentation_test_run._ReplaceUncommonChars(original),
+        'abcedfhhf')
+    original = None
+    with self.assertRaises(ValueError):
+      local_device_instrumentation_test_run._ReplaceUncommonChars(original)
+    original = ''
+    with self.assertRaises(ValueError):
+      local_device_instrumentation_test_run._ReplaceUncommonChars(original)
+
 
 if __name__ == '__main__':
   unittest.main(verbosity=2)

diff --git a/build/fuchsia/linux.sdk.sha1 b/build/fuchsia/linux.sdk.sha1
index bff53f91..b87ab98 100644
--- a/build/fuchsia/linux.sdk.sha1
+++ b/build/fuchsia/linux.sdk.sha1

@@ -1 +1 @@
-0.20200825.1.1
+0.20200826.0.1

diff --git a/build/fuchsia/mac.sdk.sha1 b/build/fuchsia/mac.sdk.sha1
index bff53f91..b87ab98 100644
--- a/build/fuchsia/mac.sdk.sha1
+++ b/build/fuchsia/mac.sdk.sha1

@@ -1 +1 @@
-0.20200825.1.1
+0.20200826.0.1

diff --git a/build/install-build-deps.sh b/build/install-build-deps.sh
index e228115..faeaa9f 100755
--- a/build/install-build-deps.sh
+++ b/build/install-build-deps.sh

@@ -473,6 +473,9 @@
 else
   nacl_list="${nacl_list} libssl1.0.0:i386"
 fi
+if package_exists libtinfo5; then
+  nacl_list="${nacl_list} libtinfo5"
+fi
 if package_exists libpng16-16; then
   lib_list="${lib_list} libpng16-16"
 else

diff --git a/build/mac_toolchain.py b/build/mac_toolchain.py
index a472b14..f851503 100755
--- a/build/mac_toolchain.py
+++ b/build/mac_toolchain.py

@@ -34,9 +34,9 @@
     # This contains binaries from Xcode 11.2.1, along with the 10.15 SDKs (aka
     # 11B53).
     'default': 'wXywrnOhzFxwLYlwO62UzRxVCjnu6DoSI2D2jrCd00gC',
-    # This contains binaries from Xcode 12 beta 5, along with the
-    # 11 SDK (aka 12A8189h).
-    'xcode_12_beta': 'MzSaRpqZju2_boJy04DQnw5xpGgiQdPU53iHdst_dHQC',
+    # This contains binaries from Xcode 12 beta 6, along with the
+    # 11 SDK (aka 12A8189n).
+    'xcode_12_beta': 'ryuntti0oS9S1LFoiPfcSQ7ax5RkYU2kz788XMbEnSUC',
 }
 
 # The toolchain will not be downloaded if the minimum OS version is not met.

diff --git a/cc/paint/draw_image.cc b/cc/paint/draw_image.cc
index 8e920f6c..afa344d 100644
--- a/cc/paint/draw_image.cc
+++ b/cc/paint/draw_image.cc

@@ -4,6 +4,8 @@
 
 #include "cc/paint/draw_image.h"
 
+#include <utility>
+
 namespace cc {
 namespace {
 
@@ -41,19 +43,22 @@
                      SkFilterQuality filter_quality,
                      const SkMatrix& matrix,
                      base::Optional<size_t> frame_index,
-                     const base::Optional<gfx::ColorSpace>& color_space)
+                     const base::Optional<gfx::ColorSpace>& color_space,
+                     float sdr_white_level)
     : paint_image_(std::move(image)),
       src_rect_(src_rect),
       filter_quality_(filter_quality),
       frame_index_(frame_index),
-      target_color_space_(color_space) {
+      target_color_space_(color_space),
+      sdr_white_level_(sdr_white_level) {
   matrix_is_decomposable_ = ExtractScale(matrix, &scale_);
 }
 
 DrawImage::DrawImage(const DrawImage& other,
                      float scale_adjustment,
                      size_t frame_index,
-                     const gfx::ColorSpace& color_space)
+                     const gfx::ColorSpace& color_space,
+                     float sdr_white_level)
     : paint_image_(other.paint_image_),
       src_rect_(other.src_rect_),
       filter_quality_(other.filter_quality_),
@@ -61,7 +66,11 @@
                           other.scale_.height() * scale_adjustment)),
       matrix_is_decomposable_(other.matrix_is_decomposable_),
       frame_index_(frame_index),
-      target_color_space_(color_space) {}
+      target_color_space_(color_space),
+      sdr_white_level_(sdr_white_level) {
+  if (sdr_white_level_ == gfx::ColorSpace::kDefaultSDRWhiteLevel)
+    sdr_white_level_ = other.sdr_white_level_;
+}
 
 DrawImage::DrawImage(const DrawImage& other) = default;
 DrawImage::DrawImage(DrawImage&& other) = default;
@@ -74,7 +83,8 @@
   return paint_image_ == other.paint_image_ && src_rect_ == other.src_rect_ &&
          filter_quality_ == other.filter_quality_ && scale_ == other.scale_ &&
          matrix_is_decomposable_ == other.matrix_is_decomposable_ &&
-         target_color_space_ == other.target_color_space_;
+         target_color_space_ == other.target_color_space_ &&
+         sdr_white_level_ == other.sdr_white_level_;
 }
 
 }  // namespace cc

diff --git a/cc/paint/draw_image.h b/cc/paint/draw_image.h
index c1c6957b..984d85ad 100644
--- a/cc/paint/draw_image.h
+++ b/cc/paint/draw_image.h

@@ -31,13 +31,15 @@
             SkFilterQuality filter_quality,
             const SkMatrix& matrix,
             base::Optional<size_t> frame_index = base::nullopt,
-            const base::Optional<gfx::ColorSpace>& color_space = base::nullopt);
+            const base::Optional<gfx::ColorSpace>& color_space = base::nullopt,
+            float sdr_white_level = gfx::ColorSpace::kDefaultSDRWhiteLevel);
   // Constructs a DrawImage from |other| by adjusting its scale and setting a
   // new color_space.
   DrawImage(const DrawImage& other,
             float scale_adjustment,
             size_t frame_index,
-            const gfx::ColorSpace& color_space);
+            const gfx::ColorSpace& color_space,
+            float sdr_white_level = gfx::ColorSpace::kDefaultSDRWhiteLevel);
   DrawImage(const DrawImage& other);
   DrawImage(DrawImage&& other);
   ~DrawImage();
@@ -63,6 +65,7 @@
     DCHECK(frame_index_.has_value());
     return frame_index_.value();
   }
+  float sdr_white_level() const { return sdr_white_level_; }
 
  private:
   PaintImage paint_image_;
@@ -72,6 +75,12 @@
   bool matrix_is_decomposable_;
   base::Optional<size_t> frame_index_;
   base::Optional<gfx::ColorSpace> target_color_space_;
+
+  // The SDR white level in nits for the display. Only if |target_color_space_|
+  // is HDR will this have a value other than kDefaultSDRWhiteLevel. Used by the
+  // ImageDecodeCache to prevent HDR images from being affected by variable SDR
+  // white levels since rasterization is always treated as SDR at present.
+  float sdr_white_level_ = gfx::ColorSpace::kDefaultSDRWhiteLevel;
 };
 
 }  // namespace cc

diff --git a/cc/test/fake_tile_manager_client.cc b/cc/test/fake_tile_manager_client.cc
index 355736f..75147a59 100644
--- a/cc/test/fake_tile_manager_client.cc
+++ b/cc/test/fake_tile_manager_client.cc

@@ -28,6 +28,10 @@
   return color_space_;
 }
 
+float FakeTileManagerClient::GetSDRWhiteLevel() const {
+  return gfx::ColorSpace::kDefaultSDRWhiteLevel;
+}
+
 size_t FakeTileManagerClient::GetFrameIndexForImage(
     const PaintImage& paint_image,
     WhichTree tree) const {

diff --git a/cc/test/fake_tile_manager_client.h b/cc/test/fake_tile_manager_client.h
index 6fb3bd4c..c9c21b7 100644
--- a/cc/test/fake_tile_manager_client.h
+++ b/cc/test/fake_tile_manager_client.h

@@ -5,6 +5,7 @@
 #ifndef CC_TEST_FAKE_TILE_MANAGER_CLIENT_H_
 #define CC_TEST_FAKE_TILE_MANAGER_CLIENT_H_
 
+#include <memory>
 #include <vector>
 
 #include "cc/tiles/tile_manager.h"
@@ -29,6 +30,7 @@
   void SetIsLikelyToRequireADraw(bool is_likely_to_require_a_draw) override {}
   gfx::ColorSpace GetRasterColorSpace(
       gfx::ContentColorUsage content_color_usage) const override;
+  float GetSDRWhiteLevel() const override;
   void RequestImplSideInvalidationForCheckerImagedTiles() override {}
   size_t GetFrameIndexForImage(const PaintImage& paint_image,
                                WhichTree tree) const override;

diff --git a/cc/tiles/gpu_image_decode_cache.cc b/cc/tiles/gpu_image_decode_cache.cc
index a2875b8..1bb3886 100644
--- a/cc/tiles/gpu_image_decode_cache.cc
+++ b/cc/tiles/gpu_image_decode_cache.cc

@@ -2071,6 +2071,12 @@
     color_space = nullptr;
   }
 
+  // Will be nullptr for non-HDR images or when we're using the default level.
+  const bool needs_adjusted_color_space =
+      NeedsColorSpaceAdjustedForUpload(draw_image);
+  if (needs_adjusted_color_space)
+    decoded_target_colorspace = ColorSpaceForImageUpload(draw_image);
+
   if (image_data->mode == DecodedDataMode::kTransferCache) {
     DCHECK(use_transfer_cache_);
     if (image_data->decode.do_hardware_accelerated_decode()) {
@@ -2132,6 +2138,9 @@
       SkPixmap pixmap;
       if (!image_data->decode.image()->peekPixels(&pixmap))
         return;
+      if (needs_adjusted_color_space)
+        pixmap.setColorSpace(decoded_target_colorspace);
+
       ClientImageTransferCacheEntry image_entry(&pixmap, color_space.get(),
                                                 image_data->needs_mips);
       InsertTransferCacheEntry(image_entry, image_data);
@@ -2234,6 +2243,12 @@
     return;
   }
 
+  // TODO(crbug.com/1120719): The RGBX path is broken for HDR images.
+  if (needs_adjusted_color_space) {
+    uploaded_image =
+        uploaded_image->reinterpretColorSpace(decoded_target_colorspace);
+  }
+
   // RGBX decoding is below.
   // For kGpu, we upload and color convert (if necessary).
   if (image_data->mode == DecodedDataMode::kGpu) {
@@ -2846,6 +2861,21 @@
   return sk_ref_sp(image.paint_image().color_space());
 }
 
+bool GpuImageDecodeCache::NeedsColorSpaceAdjustedForUpload(
+    const DrawImage& image) const {
+  return image.sdr_white_level() != gfx::ColorSpace::kDefaultSDRWhiteLevel &&
+         image.paint_image().GetContentColorUsage() ==
+             gfx::ContentColorUsage::kHDR;
+}
+
+sk_sp<SkColorSpace> GpuImageDecodeCache::ColorSpaceForImageUpload(
+    const DrawImage& image) const {
+  DCHECK(NeedsColorSpaceAdjustedForUpload(image));
+  return gfx::ColorSpace(*image.paint_image().color_space())
+      .GetWithSDRWhiteLevel(image.sdr_white_level())
+      .ToSkColorSpace();
+}
+
 void GpuImageDecodeCache::CheckContextLockAcquiredIfNecessary() {
   if (!context_->GetLock())
     return;
@@ -2967,15 +2997,17 @@
                 draw_image.target_color_space().IsValid()
             ? draw_image.target_color_space().ToSkColorSpace()
             : nullptr;
-    sk_sp<SkColorSpace> decoded_color_space =
-        ColorSpaceForImageDecode(draw_image, image_data->mode);
+    sk_sp<SkColorSpace> upload_color_space =
+        NeedsColorSpaceAdjustedForUpload(draw_image)
+            ? ColorSpaceForImageUpload(draw_image)
+            : ColorSpaceForImageDecode(draw_image, image_data->mode);
     DCHECK(image_data->yuv_color_space.has_value());
     sk_sp<SkImage> yuv_image_with_mips_owned =
         CreateImageFromYUVATexturesInternal(
             image_y_with_mips_owned.get(), image_u_with_mips_owned.get(),
             image_v_with_mips_owned.get(), width, height,
             image_data->yuv_color_space.value(), color_space,
-            decoded_color_space);
+            upload_color_space);
     // In case of lost context
     if (!yuv_image_with_mips_owned) {
       DLOG(WARNING) << "TODO(crbug.com/740737): Context was lost. Early out.";
@@ -3008,6 +3040,15 @@
   // delete, delaying deletion.
   sk_sp<SkImage> previous_image = image_data->upload.image();
 
+#if DCHECK_IS_ON()
+  // For already uploaded images, the correct color space should already have
+  // been set during the upload process.
+  if (NeedsColorSpaceAdjustedForUpload(draw_image)) {
+    DCHECK(SkColorSpace::Equals(previous_image->colorSpace(),
+                                ColorSpaceForImageUpload(draw_image).get()));
+  }
+#endif
+
   // Generate a new image from the previous, adding mips.
   sk_sp<SkImage> image_with_mips = previous_image->makeTextureImage(
       context_->GrContext(), GrMipMapped::kYes);

diff --git a/cc/tiles/gpu_image_decode_cache.h b/cc/tiles/gpu_image_decode_cache.h
index bdf38e5..a65ba526 100644
--- a/cc/tiles/gpu_image_decode_cache.h
+++ b/cc/tiles/gpu_image_decode_cache.h

@@ -675,6 +675,11 @@
   sk_sp<SkColorSpace> ColorSpaceForImageDecode(const DrawImage& image,
                                                DecodedDataMode mode) const;
 
+  // HDR images need the SkColorSpace adjusted during upload to avoid white
+  // level issues on systems with variable SDR white levels (Windows).
+  bool NeedsColorSpaceAdjustedForUpload(const DrawImage& image) const;
+  sk_sp<SkColorSpace> ColorSpaceForImageUpload(const DrawImage& image) const;
+
   // Helper function to add a memory dump to |pmd| for a single texture
   // identified by |gl_id| with size |bytes| and |locked_size| equal to either
   // |bytes| or 0 depending on whether the texture is currently locked.

diff --git a/cc/tiles/gpu_image_decode_cache_unittest.cc b/cc/tiles/gpu_image_decode_cache_unittest.cc
index be5c137..0cf8325 100644
--- a/cc/tiles/gpu_image_decode_cache_unittest.cc
+++ b/cc/tiles/gpu_image_decode_cache_unittest.cc

@@ -468,7 +468,8 @@
       gfx::ColorSpace* color_space = nullptr,
       SkFilterQuality filter_quality = kMedium_SkFilterQuality,
       SkIRect* src_rect = nullptr,
-      size_t frame_index = PaintImage::kDefaultFrameIndex) {
+      size_t frame_index = PaintImage::kDefaultFrameIndex,
+      float sdr_white_level = gfx::ColorSpace::kDefaultSDRWhiteLevel) {
     SkIRect src_rectangle;
     gfx::ColorSpace cs;
     if (!src_rect) {
@@ -481,7 +482,7 @@
       color_space = &cs;
     }
     return DrawImage(paint_image, *src_rect, filter_quality, matrix,
-                     frame_index, *color_space);
+                     frame_index, *color_space, sdr_white_level);
   }
 
   GPUImageDecodeTestMockContextProvider* context_provider() {
@@ -573,7 +574,8 @@
       const DrawImage& draw_image,
       const base::Optional<uint32_t> transfer_cache_id,
       const SkISize plane_sizes[SkYUVASizeInfo::kMaxCount],
-      SkColorType expected_type = kGray_8_SkColorType) {
+      SkColorType expected_type = kGray_8_SkColorType,
+      const SkColorSpace* expected_cs = nullptr) {
     for (size_t i = 0; i < SkYUVASizeInfo::kMaxCount; ++i) {
       // TODO(crbug.com/910276): Skip alpha plane until supported in cache.
       if (i != SkYUVAIndex::kA_Index) {
@@ -591,6 +593,12 @@
         ASSERT_TRUE(uploaded_plane);
         EXPECT_EQ(plane_sizes[i], uploaded_plane->dimensions());
         EXPECT_EQ(expected_type, uploaded_plane->colorType());
+        if (expected_cs && use_transfer_cache_) {
+          EXPECT_TRUE(
+              SkColorSpace::Equals(expected_cs, uploaded_plane->colorSpace()));
+        } else if (expected_cs) {
+          // In-process raster sets the ColorSpace on the composite SkImage.
+        }
       }
     }
   }
@@ -1104,8 +1112,11 @@
                                     PaintImage::GetNextContentId())
                          .TakePaintImage();
 
+  constexpr float kCustomWhiteLevel = 200.f;
   DrawImage draw_image = CreateDrawImageInternal(
-      image, CreateMatrix(SkSize::Make(0.5f, 0.5f)), &color_space);
+      image, CreateMatrix(SkSize::Make(0.5f, 0.5f)), &color_space,
+      kMedium_SkFilterQuality, nullptr, PaintImage::kDefaultFrameIndex,
+      kCustomWhiteLevel);
   ImageDecodeCache::TaskResult result =
       cache->GetTaskForImageAndRef(draw_image, ImageDecodeCache::TracingInfo());
   EXPECT_EQ(draw_image.target_color_space(), color_space);
@@ -1127,6 +1138,11 @@
   EXPECT_TRUE(decoded_draw_image.is_budgeted());
   EXPECT_EQ(decoded_draw_image.image()->colorType(), kRGBA_F16_SkColorType);
 
+  auto cs = gfx::ColorSpace(*decoded_draw_image.image()->colorSpace());
+  float sdr_white_level;
+  ASSERT_TRUE(cs.GetPQSDRWhiteLevel(&sdr_white_level));
+  EXPECT_FLOAT_EQ(sdr_white_level, kCustomWhiteLevel);
+
   EXPECT_FALSE(cache->DiscardableIsLockedForTesting(draw_image));
 
   cache->DrawWithImageFinished(draw_image, decoded_draw_image);
@@ -2974,20 +2990,32 @@
   }
 
   auto decode_and_check_plane_sizes = [this](GpuImageDecodeCache* cache,
-                                             SkColorType yuv_color_type) {
+                                             SkColorType yuv_color_type,
+                                             gfx::ColorSpace target_cs) {
     SkFilterQuality filter_quality = kMedium_SkFilterQuality;
     SkSize requires_decode_at_original_scale = SkSize::Make(0.8f, 0.8f);
 
+    // When we're targeting HDR output, select a reasonable HDR color space for
+    // the decoded content.
+    gfx::ColorSpace decoded_cs;
+    if (target_cs.IsHDR())
+      decoded_cs = gfx::ColorSpace::CreateHDR10();
+
     // An unknown SkColorType means we expect fallback to RGB.
     PaintImage image =
         yuv_color_type == kUnknown_SkColorType
             ? CreatePaintImageForFallbackToRGB(GetNormalImageSize())
-            : CreatePaintImageInternal(GetNormalImageSize());
+            : CreatePaintImageInternal(GetNormalImageSize(),
+                                       decoded_cs.ToSkColorSpace());
 
-    DrawImage draw_image(image, SkIRect::MakeWH(image.width(), image.height()),
-                         filter_quality,
-                         CreateMatrix(requires_decode_at_original_scale),
-                         PaintImage::kDefaultFrameIndex, DefaultColorSpace());
+    float sdr_white_level = gfx::ColorSpace::kDefaultSDRWhiteLevel;
+    if (target_cs.IsHDR())
+      ASSERT_TRUE(target_cs.GetPQSDRWhiteLevel(&sdr_white_level));
+
+    DrawImage draw_image(
+        image, SkIRect::MakeWH(image.width(), image.height()), filter_quality,
+        CreateMatrix(requires_decode_at_original_scale),
+        PaintImage::kDefaultFrameIndex, target_cs, sdr_white_level);
     ImageDecodeCache::TaskResult result = cache->GetTaskForImageAndRef(
         draw_image, ImageDecodeCache::TracingInfo());
     EXPECT_TRUE(result.need_unref);
@@ -3019,8 +3047,22 @@
                                        true /* should_have_mips */);
       SkYUVASizeInfo yuv_size_info = GetYUVASizeInfo(
           GetNormalImageSize(), yuv_format_, yuv_bytes_per_pixel_);
+
+      // Decoded HDR images should have their SDR white level adjusted to match
+      // the display so we avoid scaling them by variable SDR brightness levels.
+      auto expected_cs = decoded_cs.IsHDR()
+                             ? decoded_cs.GetWithSDRWhiteLevel(sdr_white_level)
+                             : decoded_cs;
+
       VerifyUploadedPlaneSizes(cache, draw_image, transfer_cache_entry_id,
-                               yuv_size_info.fSizes, yuv_color_type);
+                               yuv_size_info.fSizes, yuv_color_type,
+                               expected_cs.ToSkColorSpace().get());
+
+      if (expected_cs.IsValid()) {
+        EXPECT_TRUE(
+            SkColorSpace::Equals(expected_cs.ToSkColorSpace().get(),
+                                 decoded_draw_image.image()->colorSpace()));
+      }
     } else {
       if (use_transfer_cache_) {
         EXPECT_FALSE(transfer_cache_helper_
@@ -3048,6 +3090,8 @@
     original_caps = context_provider_->ContextCapabilities();
   }
 
+  const auto hdr_cs = gfx::ColorSpace::CreateHDR10(/*sdr_white_level=*/200.0f);
+
   // Ensure that when R16 is supported, it's used and preferred over half-float.
   {
     auto r16_caps = original_caps;
@@ -3057,13 +3101,29 @@
     auto r16_cache = CreateCache();
 
     yuv_format_ = YUVSubsampling::k420;
-    decode_and_check_plane_sizes(r16_cache.get(), kA16_unorm_SkColorType);
+    decode_and_check_plane_sizes(r16_cache.get(), kA16_unorm_SkColorType,
+                                 DefaultColorSpace());
 
     yuv_format_ = YUVSubsampling::k422;
-    decode_and_check_plane_sizes(r16_cache.get(), kA16_unorm_SkColorType);
+    decode_and_check_plane_sizes(r16_cache.get(), kA16_unorm_SkColorType,
+                                 DefaultColorSpace());
 
     yuv_format_ = YUVSubsampling::k444;
-    decode_and_check_plane_sizes(r16_cache.get(), kA16_unorm_SkColorType);
+    decode_and_check_plane_sizes(r16_cache.get(), kA16_unorm_SkColorType,
+                                 DefaultColorSpace());
+
+    // Verify HDR decoding has white level adjustment.
+    yuv_format_ = YUVSubsampling::k420;
+    decode_and_check_plane_sizes(r16_cache.get(), kA16_unorm_SkColorType,
+                                 hdr_cs);
+
+    yuv_format_ = YUVSubsampling::k422;
+    decode_and_check_plane_sizes(r16_cache.get(), kA16_unorm_SkColorType,
+                                 hdr_cs);
+
+    yuv_format_ = YUVSubsampling::k444;
+    decode_and_check_plane_sizes(r16_cache.get(), kA16_unorm_SkColorType,
+                                 hdr_cs);
   }
 
   // Verify that half-float is used when R16 is not available.
@@ -3075,13 +3135,29 @@
     auto f16_cache = CreateCache();
 
     yuv_format_ = YUVSubsampling::k420;
-    decode_and_check_plane_sizes(f16_cache.get(), kA16_float_SkColorType);
+    decode_and_check_plane_sizes(f16_cache.get(), kA16_float_SkColorType,
+                                 DefaultColorSpace());
 
     yuv_format_ = YUVSubsampling::k422;
-    decode_and_check_plane_sizes(f16_cache.get(), kA16_float_SkColorType);
+    decode_and_check_plane_sizes(f16_cache.get(), kA16_float_SkColorType,
+                                 DefaultColorSpace());
 
     yuv_format_ = YUVSubsampling::k444;
-    decode_and_check_plane_sizes(f16_cache.get(), kA16_float_SkColorType);
+    decode_and_check_plane_sizes(f16_cache.get(), kA16_float_SkColorType,
+                                 DefaultColorSpace());
+
+    // Verify HDR decoding has white level adjustment.
+    yuv_format_ = YUVSubsampling::k420;
+    decode_and_check_plane_sizes(f16_cache.get(), kA16_float_SkColorType,
+                                 hdr_cs);
+
+    yuv_format_ = YUVSubsampling::k422;
+    decode_and_check_plane_sizes(f16_cache.get(), kA16_float_SkColorType,
+                                 hdr_cs);
+
+    yuv_format_ = YUVSubsampling::k444;
+    decode_and_check_plane_sizes(f16_cache.get(), kA16_float_SkColorType,
+                                 hdr_cs);
   }
 
   // Verify YUV16 is unsupported when neither R16 or half-float are available.
@@ -3093,13 +3169,16 @@
     auto no_yuv16_cache = CreateCache();
 
     yuv_format_ = YUVSubsampling::k420;
-    decode_and_check_plane_sizes(no_yuv16_cache.get(), kUnknown_SkColorType);
+    decode_and_check_plane_sizes(no_yuv16_cache.get(), kUnknown_SkColorType,
+                                 DefaultColorSpace());
 
     yuv_format_ = YUVSubsampling::k422;
-    decode_and_check_plane_sizes(no_yuv16_cache.get(), kUnknown_SkColorType);
+    decode_and_check_plane_sizes(no_yuv16_cache.get(), kUnknown_SkColorType,
+                                 DefaultColorSpace());
 
     yuv_format_ = YUVSubsampling::k444;
-    decode_and_check_plane_sizes(no_yuv16_cache.get(), kUnknown_SkColorType);
+    decode_and_check_plane_sizes(no_yuv16_cache.get(), kUnknown_SkColorType,
+                                 DefaultColorSpace());
   }
 }
 

diff --git a/cc/tiles/tile_manager.cc b/cc/tiles/tile_manager.cc
index 2d275cd..88dac92 100644
--- a/cc/tiles/tile_manager.cc
+++ b/cc/tiles/tile_manager.cc

@@ -747,6 +747,7 @@
         GetContentColorUsageForPrioritizedTile(prioritized_tile);
     const gfx::ColorSpace raster_color_space =
         client_->GetRasterColorSpace(content_color_usage);
+    const float sdr_white_level = client_->GetSDRWhiteLevel();
 
     // Tiles in the raster queue should either require raster or decode for
     // checker-images. If this tile does not need raster, process it only to
@@ -758,7 +759,7 @@
       DCHECK(prioritized_tile.should_decode_checkered_images_for_tile());
 
       AddCheckeredImagesToDecodeQueue(
-          prioritized_tile, raster_color_space,
+          prioritized_tile, raster_color_space, sdr_white_level,
           CheckerImageTracker::DecodeType::kRaster,
           &work_to_schedule.checker_image_decode_queue);
       continue;
@@ -819,7 +820,7 @@
       if (tile->raster_task_scheduled_with_checker_images() &&
           prioritized_tile.should_decode_checkered_images_for_tile()) {
         AddCheckeredImagesToDecodeQueue(
-            prioritized_tile, raster_color_space,
+            prioritized_tile, raster_color_space, sdr_white_level,
             CheckerImageTracker::DecodeType::kRaster,
             &work_to_schedule.checker_image_decode_queue);
       }
@@ -827,7 +828,7 @@
       // Creating the raster task here will acquire resources, but
       // this resource usage has already been accounted for above.
       auto raster_task = CreateRasterTask(prioritized_tile, raster_color_space,
-                                          &work_to_schedule);
+                                          sdr_white_level, &work_to_schedule);
       if (!raster_task) {
         continue;
       }
@@ -867,12 +868,13 @@
           GetContentColorUsageForPrioritizedTile(prioritized_tile);
       gfx::ColorSpace raster_color_space =
           client_->GetRasterColorSpace(content_color_usage);
+      const float sdr_white_level = client_->GetSDRWhiteLevel();
 
       Tile* tile = prioritized_tile.tile();
       if (tile->draw_info().is_checker_imaged() ||
           tile->raster_task_scheduled_with_checker_images()) {
         AddCheckeredImagesToDecodeQueue(
-            prioritized_tile, raster_color_space,
+            prioritized_tile, raster_color_space, sdr_white_level,
             CheckerImageTracker::DecodeType::kRaster,
             &work_to_schedule.checker_image_decode_queue);
       }
@@ -923,6 +925,7 @@
 void TileManager::PartitionImagesForCheckering(
     const PrioritizedTile& prioritized_tile,
     const gfx::ColorSpace& raster_color_space,
+    float sdr_white_level,
     std::vector<DrawImage>* sync_decoded_images,
     std::vector<PaintImage>* checkered_images,
     const gfx::Rect* invalidated_rect,
@@ -945,7 +948,7 @@
       (*image_to_frame_index)[image.stable_id()] = frame_index;
 
     DrawImage draw_image(*original_draw_image, tile->raster_transform().scale(),
-                         frame_index, raster_color_space);
+                         frame_index, raster_color_space, sdr_white_level);
     if (checker_image_tracker_.ShouldCheckerImage(draw_image, tree))
       checkered_images->push_back(draw_image.paint_image());
     else
@@ -956,6 +959,7 @@
 void TileManager::AddCheckeredImagesToDecodeQueue(
     const PrioritizedTile& prioritized_tile,
     const gfx::ColorSpace& raster_color_space,
+    float sdr_white_level,
     CheckerImageTracker::DecodeType decode_type,
     CheckerImageTracker::ImageDecodeQueue* image_decode_queue) {
   Tile* tile = prioritized_tile.tile();
@@ -963,12 +967,11 @@
   prioritized_tile.raster_source()->GetDiscardableImagesInRect(
       tile->enclosing_layer_rect(), &images_in_tile);
   WhichTree tree = tile->tiling()->tree();
-
   for (const auto* original_draw_image : images_in_tile) {
     size_t frame_index = client_->GetFrameIndexForImage(
         original_draw_image->paint_image(), tree);
     DrawImage draw_image(*original_draw_image, tile->raster_transform().scale(),
-                         frame_index, raster_color_space);
+                         frame_index, raster_color_space, sdr_white_level);
     if (checker_image_tracker_.ShouldCheckerImage(draw_image, tree)) {
       image_decode_queue->emplace_back(draw_image.paint_image(), decode_type);
     }
@@ -1062,12 +1065,13 @@
         GetContentColorUsageForPrioritizedTile(prioritized_tile);
     gfx::ColorSpace raster_color_space =
         client_->GetRasterColorSpace(content_color_usage);
+    float sdr_white_level = client_->GetSDRWhiteLevel();
 
     std::vector<DrawImage> sync_decoded_images;
     std::vector<PaintImage> checkered_images;
     PartitionImagesForCheckering(prioritized_tile, raster_color_space,
-                                 &sync_decoded_images, &checkered_images,
-                                 nullptr);
+                                 sdr_white_level, &sync_decoded_images,
+                                 &checkered_images, nullptr);
 
     // Add the sync decoded images to |new_locked_images| so they can be added
     // to the task graph.
@@ -1161,6 +1165,7 @@
 scoped_refptr<TileTask> TileManager::CreateRasterTask(
     const PrioritizedTile& prioritized_tile,
     const gfx::ColorSpace& raster_color_space,
+    float sdr_white_level,
     PrioritizedWorkToSchedule* work_to_schedule) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "TileManager::CreateRasterTask");
@@ -1222,8 +1227,9 @@
   base::flat_map<PaintImage::Id, size_t> image_id_to_current_frame_index;
   if (!skip_images) {
     PartitionImagesForCheckering(
-        prioritized_tile, raster_color_space, &sync_decoded_images,
-        &checkered_images, partial_tile_decode ? &invalidated_rect : nullptr,
+        prioritized_tile, raster_color_space, sdr_white_level,
+        &sync_decoded_images, &checkered_images,
+        partial_tile_decode ? &invalidated_rect : nullptr,
         &image_id_to_current_frame_index);
   }
 

diff --git a/cc/tiles/tile_manager.h b/cc/tiles/tile_manager.h
index 0e0b02f..c36a82a 100644
--- a/cc/tiles/tile_manager.h
+++ b/cc/tiles/tile_manager.h

@@ -85,6 +85,12 @@
   virtual gfx::ColorSpace GetRasterColorSpace(
       gfx::ContentColorUsage content_color_usage) const = 0;
 
+  // Return the SDR white level for rasterization. Some systems have variable
+  // white levels (e.g., Windows SDR brightness slider). This should return the
+  // level of the monitor on which the rasterized content will be displayed (and
+  // changing the SDR white level of the display will trigger a re-raster).
+  virtual float GetSDRWhiteLevel() const = 0;
+
   // Requests that a pending tree be scheduled to invalidate content on the
   // pending on active tree. This is currently used when tiles that are
   // rasterized with missing images need to be invalidated.
@@ -365,6 +371,7 @@
   scoped_refptr<TileTask> CreateRasterTask(
       const PrioritizedTile& prioritized_tile,
       const gfx::ColorSpace& raster_color_space,
+      float sdr_white_level,
       PrioritizedWorkToSchedule* work_to_schedule);
 
   std::unique_ptr<EvictionTilePriorityQueue>
@@ -398,6 +405,7 @@
   void PartitionImagesForCheckering(
       const PrioritizedTile& prioritized_tile,
       const gfx::ColorSpace& raster_color_space,
+      float sdr_white_level,
       std::vector<DrawImage>* sync_decoded_images,
       std::vector<PaintImage>* checkered_images,
       const gfx::Rect* invalidated_rect,
@@ -405,6 +413,7 @@
   void AddCheckeredImagesToDecodeQueue(
       const PrioritizedTile& prioritized_tile,
       const gfx::ColorSpace& raster_color_space,
+      float sdr_white_level,
       CheckerImageTracker::DecodeType decode_type,
       CheckerImageTracker::ImageDecodeQueue* image_decode_queue);
 

diff --git a/cc/tiles/tile_manager_unittest.cc b/cc/tiles/tile_manager_unittest.cc
index 626fa807..13703e7f 100644
--- a/cc/tiles/tile_manager_unittest.cc
+++ b/cc/tiles/tile_manager_unittest.cc

@@ -3452,9 +3452,13 @@
     constexpr gfx::Size kTileSize(500, 500);
     Region invalidation((gfx::Rect(kLayerBounds)));
     SetupPendingTree(raster_source, kTileSize, invalidation);
-    pending_layer()->layer_tree_impl()->SetDisplayColorSpaces(
-        gfx::DisplayColorSpaces(raster_cs));
 
+    constexpr float kCustomWhiteLevel = 200.f;
+    auto display_cs = gfx::DisplayColorSpaces(raster_cs);
+    if (raster_cs.IsHDR())
+      display_cs.SetSDRWhiteLevel(kCustomWhiteLevel);
+
+    pending_layer()->layer_tree_impl()->SetDisplayColorSpaces(display_cs);
     PictureLayerTilingSet* tiling_set =
         pending_layer()->picture_layer_tiling_set();
     PictureLayerTiling* pending_tiling = tiling_set->tiling_at(0);
@@ -3469,6 +3473,21 @@
     host_impl()->tile_manager()->PrepareTiles(host_impl()->global_tile_state());
     ASSERT_TRUE(host_impl()->tile_manager()->HasScheduledTileTasksForTesting());
 
+    auto pending_tiles = pending_tiling->AllTilesForTesting();
+    ASSERT_FALSE(pending_tiles.empty());
+
+    if (raster_cs.IsHDR()) {
+      // Only the last tile will have any pending tasks.
+      const auto& pending_tasks =
+          host_impl()->tile_manager()->decode_tasks_for_testing(
+              pending_tiles.back()->id());
+      EXPECT_FALSE(pending_tasks.empty());
+      for (const auto& draw_info : pending_tasks) {
+        EXPECT_EQ(draw_info.target_color_space(), raster_cs);
+        EXPECT_FLOAT_EQ(draw_info.sdr_white_level(), kCustomWhiteLevel);
+      }
+    }
+
     // Raster all tiles.
     static_cast<SynchronousTaskGraphRunner*>(task_graph_runner())
         ->RunUntilIdle();

diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index c6ad4d4..16bb248 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc

@@ -1779,11 +1779,14 @@
   }
 
   // The pending tree will has the most recently updated color space, so use it.
-  gfx::ColorSpace result;
+  gfx::DisplayColorSpaces display_cs;
   if (pending_tree_)
-    result = pending_tree_->display_color_spaces().GetScreenInfoColorSpace();
+    display_cs = pending_tree_->display_color_spaces();
   else if (active_tree_)
-    result = active_tree_->display_color_spaces().GetScreenInfoColorSpace();
+    display_cs = active_tree_->display_color_spaces();
+
+  auto result = display_cs.GetOutputColorSpace(gfx::ContentColorUsage::kHDR,
+                                               /*needs_alpha=*/false);
 
   // Always specify a color space if color correct rasterization is requested
   // (not specifying a color space indicates that no color conversion is
@@ -1799,6 +1802,20 @@
   return result;
 }
 
+float LayerTreeHostImpl::GetSDRWhiteLevel() const {
+  // If we are likely to software composite the resource, we use sRGB because
+  // software compositing is unable to perform color conversion.
+  if (!layer_tree_frame_sink_ || !layer_tree_frame_sink_->context_provider())
+    return gfx::ColorSpace::kDefaultSDRWhiteLevel;
+
+  // The pending tree will has the most recently updated color space, so use it.
+  if (pending_tree_)
+    return pending_tree_->display_color_spaces().GetSDRWhiteLevel();
+  if (active_tree_)
+    return active_tree_->display_color_spaces().GetSDRWhiteLevel();
+  return gfx::ColorSpace::kDefaultSDRWhiteLevel;
+}
+
 void LayerTreeHostImpl::RequestImplSideInvalidationForCheckerImagedTiles() {
   // When using impl-side invalidation for checker-imaging, a pending tree does
   // not need to be flushed as an independent update through the pipeline.

diff --git a/cc/trees/layer_tree_host_impl.h b/cc/trees/layer_tree_host_impl.h
index 6b17453..c2f8b67 100644
--- a/cc/trees/layer_tree_host_impl.h
+++ b/cc/trees/layer_tree_host_impl.h

@@ -535,6 +535,7 @@
   void SetIsLikelyToRequireADraw(bool is_likely_to_require_a_draw) override;
   gfx::ColorSpace GetRasterColorSpace(
       gfx::ContentColorUsage content_color_usage) const override;
+  float GetSDRWhiteLevel() const override;
   void RequestImplSideInvalidationForCheckerImagedTiles() override;
   size_t GetFrameIndexForImage(const PaintImage& paint_image,
                                WhichTree tree) const override;

diff --git a/cc/trees/layer_tree_host_impl_unittest.cc b/cc/trees/layer_tree_host_impl_unittest.cc
index 52904e6..745bd7a 100644
--- a/cc/trees/layer_tree_host_impl_unittest.cc
+++ b/cc/trees/layer_tree_host_impl_unittest.cc

@@ -15842,6 +15842,8 @@
   EXPECT_EQ(
       host_impl_->GetRasterColorSpace(gfx::ContentColorUsage::kWideColorGamut),
       gfx::ColorSpace::CreateDisplayP3D65());
+  EXPECT_EQ(gfx::ColorSpace::kDefaultSDRWhiteLevel,
+            host_impl_->GetSDRWhiteLevel());
 }
 
 TEST_P(ScrollUnifiedLayerTreeHostImplTest, RasterColorSpaceSoftware) {
@@ -15856,6 +15858,8 @@
   EXPECT_EQ(
       host_impl_->GetRasterColorSpace(gfx::ContentColorUsage::kWideColorGamut),
       gfx::ColorSpace::CreateSRGB());
+  EXPECT_EQ(gfx::ColorSpace::kDefaultSDRWhiteLevel,
+            host_impl_->GetSDRWhiteLevel());
 }
 
 TEST_P(ScrollUnifiedLayerTreeHostImplTest, RasterColorPrefersSRGB) {
@@ -15872,6 +15876,8 @@
   CreateHostImpl(settings, CreateLayerTreeFrameSink());
   host_impl_->active_tree()->SetDisplayColorSpaces(gfx::DisplayColorSpaces(p3));
   EXPECT_EQ(host_impl_->GetRasterColorSpace(gfx::ContentColorUsage::kSRGB), p3);
+  EXPECT_EQ(gfx::ColorSpace::kDefaultSDRWhiteLevel,
+            host_impl_->GetSDRWhiteLevel());
 }
 
 TEST_P(ScrollUnifiedLayerTreeHostImplTest, RasterColorSpaceHDR) {
@@ -15890,6 +15896,23 @@
       gfx::ColorSpace::CreateDisplayP3D65());
 
   EXPECT_EQ(host_impl_->GetRasterColorSpace(gfx::ContentColorUsage::kHDR), hdr);
+  EXPECT_EQ(gfx::ColorSpace::kDefaultSDRWhiteLevel,
+            host_impl_->GetSDRWhiteLevel());
+}
+
+TEST_P(ScrollUnifiedLayerTreeHostImplTest, SDRWhiteLevel) {
+  constexpr float kCustomWhiteLevel = 200.f;
+  auto hdr = gfx::ColorSpace::CreateHDR10();
+  auto display_cs = gfx::DisplayColorSpaces(hdr);
+  display_cs.SetSDRWhiteLevel(kCustomWhiteLevel);
+
+  LayerTreeSettings settings = DefaultSettings();
+  CreateHostImpl(settings, CreateLayerTreeFrameSink());
+  host_impl_->active_tree()->SetDisplayColorSpaces(display_cs);
+
+  // Non-HDR content should be rasterized in P3.
+  EXPECT_EQ(host_impl_->GetRasterColorSpace(gfx::ContentColorUsage::kHDR), hdr);
+  EXPECT_EQ(kCustomWhiteLevel, host_impl_->GetSDRWhiteLevel());
 }
 
 TEST_P(ScrollUnifiedLayerTreeHostImplTest, UpdatedTilingsForNonDrawingLayers) {

diff --git a/chrome/VERSION b/chrome/VERSION
index e35c032..7b9c74a6 100644
--- a/chrome/VERSION
+++ b/chrome/VERSION

@@ -1,4 +1,4 @@
 MAJOR=87
 MINOR=0
-BUILD=4245
+BUILD=4246
 PATCH=0

diff --git a/chrome/android/BUILD.gn b/chrome/android/BUILD.gn
index f37d7f7d..6acdb9c 100644
--- a/chrome/android/BUILD.gn
+++ b/chrome/android/BUILD.gn

@@ -350,6 +350,7 @@
     "//components/browser_ui/android/bottomsheet:manager_java",
     "//components/browser_ui/banners/android:java",
     "//components/browser_ui/client_certificate/android:java",
+    "//components/browser_ui/contacts_picker/android:java",
     "//components/browser_ui/display_cutout/android:java",
     "//components/browser_ui/http_auth/android:java",
     "//components/browser_ui/media/android:java",
@@ -538,7 +539,6 @@
     "//components/payments/content/android:method_strings_generated_srcjar",
     "//components/search_engines:search_engine_type_java",
     "//components/ui_metrics:ui_metrics_enums_java",
-    "//content/public/browser:contacts_picker_properties_requested_javagen",
     "//net:effective_connection_type_java",
   ]
 
@@ -1023,6 +1023,7 @@
     "//components/bookmarks/common/android:bookmarks_java",
     "//components/browser_ui/android/bottomsheet:java",
     "//components/browser_ui/android/bottomsheet/test:java",
+    "//components/browser_ui/contacts_picker/android:javatests",
     "//components/browser_ui/display_cutout/android:java",
     "//components/browser_ui/media/android:java",
     "//components/browser_ui/modaldialog/android:java",

diff --git a/chrome/android/DEPS b/chrome/android/DEPS
index 9c41913a..eb220a1 100644
--- a/chrome/android/DEPS
+++ b/chrome/android/DEPS

@@ -19,6 +19,7 @@
   "+chrome/browser/webauthn/android",
   "+components/browser_ui/android/bottomsheet",
   "+components/browser_ui/banners/android",
+  "+components/browser_ui/contacts_picker/android",
   "+components/browser_ui/display_cutout/android",
   "+components/browser_ui/media/android",
   "+components/browser_ui/modaldialog/android",

diff --git a/chrome/android/chrome_java_resources.gni b/chrome/android/chrome_java_resources.gni
index 2ee7c23..6a644c8 100644
--- a/chrome/android/chrome_java_resources.gni
+++ b/chrome/android/chrome_java_resources.gni

@@ -42,7 +42,6 @@
   "java/res/drawable-hdpi/btn_normal_tabs.png",
   "java/res/drawable-hdpi/btn_right.png",
   "java/res/drawable-hdpi/btn_star.png",
-  "java/res/drawable-hdpi/btn_star_filled.png",
   "java/res/drawable-hdpi/btn_suggestion_refine.png",
   "java/res/drawable-hdpi/btn_tab_close_normal.png",
   "java/res/drawable-hdpi/btn_tabstrip_new_incognito_tab_normal.png",
@@ -191,7 +190,6 @@
   "java/res/drawable-mdpi/btn_normal_tabs.png",
   "java/res/drawable-mdpi/btn_right.png",
   "java/res/drawable-mdpi/btn_star.png",
-  "java/res/drawable-mdpi/btn_star_filled.png",
   "java/res/drawable-mdpi/btn_suggestion_refine.png",
   "java/res/drawable-mdpi/btn_tab_close_normal.png",
   "java/res/drawable-mdpi/btn_tabstrip_new_incognito_tab_normal.png",
@@ -324,7 +322,6 @@
   "java/res/drawable-xhdpi/btn_normal_tabs.png",
   "java/res/drawable-xhdpi/btn_right.png",
   "java/res/drawable-xhdpi/btn_star.png",
-  "java/res/drawable-xhdpi/btn_star_filled.png",
   "java/res/drawable-xhdpi/btn_suggestion_refine.png",
   "java/res/drawable-xhdpi/btn_tab_close_normal.png",
   "java/res/drawable-xhdpi/btn_tabstrip_new_incognito_tab_normal.png",
@@ -436,7 +433,6 @@
   "java/res/drawable-xxhdpi/btn_normal_tabs.png",
   "java/res/drawable-xxhdpi/btn_right.png",
   "java/res/drawable-xxhdpi/btn_star.png",
-  "java/res/drawable-xxhdpi/btn_star_filled.png",
   "java/res/drawable-xxhdpi/btn_suggestion_refine.png",
   "java/res/drawable-xxhdpi/btn_tab_close_normal.png",
   "java/res/drawable-xxhdpi/btn_tabstrip_new_incognito_tab_normal.png",
@@ -547,7 +543,6 @@
   "java/res/drawable-xxxhdpi/btn_normal_tabs.png",
   "java/res/drawable-xxxhdpi/btn_right.png",
   "java/res/drawable-xxxhdpi/btn_star.png",
-  "java/res/drawable-xxxhdpi/btn_star_filled.png",
   "java/res/drawable-xxxhdpi/btn_suggestion_refine.png",
   "java/res/drawable-xxxhdpi/btn_tab_close_normal.png",
   "java/res/drawable-xxxhdpi/btn_tabstrip_new_incognito_tab_normal.png",
@@ -641,7 +636,6 @@
   "java/res/drawable-xxxhdpi/verify_checkmark.png",
   "java/res/drawable/accessibility_tab_switcher_divider.xml",
   "java/res/drawable/account_picker_background.xml",
-  "java/res/drawable/address.xml",
   "java/res/drawable/bg_white_dialog.xml",
   "java/res/drawable/bookmark_title_bar_shadow.xml",
   "java/res/drawable/bookmark_widget_list_selector.xml",
@@ -661,9 +655,7 @@
   "java/res/drawable/distilled_page_pref_background.xml",
   "java/res/drawable/distilled_page_prefs_button_bg.xml",
   "java/res/drawable/elo_card.xml",
-  "java/res/drawable/email.xml",
   "java/res/drawable/explore_sites_dense_tile_background.xml",
-  "java/res/drawable/face.xml",
   "java/res/drawable/google_pay.xml",
   "java/res/drawable/google_pay_with_divider.xml",
   "java/res/drawable/homepage_promo_illustration_vector.xml",
@@ -749,7 +741,6 @@
   "java/res/drawable/material_tooltip_background.xml",
   "java/res/drawable/mir_card.xml",
   "java/res/drawable/modern_toolbar_text_box_background_with_primary_color.xml",
-  "java/res/drawable/names.xml",
   "java/res/drawable/new_tab_icon.xml",
   "java/res/drawable/password_check_warning.xml",
   "java/res/drawable/password_check_warning_dark_mode.xml",
@@ -773,7 +764,6 @@
   "java/res/drawable/store_locally_tooltip_background.xml",
   "java/res/drawable/switch_to_tab.xml",
   "java/res/drawable/tab_indicator.xml",
-  "java/res/drawable/telephone.xml",
   "java/res/drawable/thumbnail_gradient_top_left.xml",
   "java/res/drawable/thumbnail_gradient_top_right.xml",
   "java/res/drawable/tile_view_hairline_border_background.xml",
@@ -833,17 +823,12 @@
   "java/res/layout/bottom_toolbar_browsing.xml",
   "java/res/layout/bottom_toolbar_menu_button.xml",
   "java/res/layout/bottom_toolbar_tab_switcher.xml",
-  "java/res/layout/checkbox_layout.xml",
   "java/res/layout/clear_browsing_data_button.xml",
   "java/res/layout/clear_browsing_data_tabs.xml",
   "java/res/layout/clear_browsing_important_dialog_listview.xml",
   "java/res/layout/compositor_view_holder.xml",
   "java/res/layout/confirm_import_sync_data.xml",
   "java/res/layout/confirm_important_sites_list_row.xml",
-  "java/res/layout/contact_view.xml",
-  "java/res/layout/contacts_list_item_view.xml",
-  "java/res/layout/contacts_picker_dialog.xml",
-  "java/res/layout/contacts_picker_toolbar.xml",
   "java/res/layout/contextual_search_bar_banner_text_view.xml",
   "java/res/layout/contextual_search_caption_view.xml",
   "java/res/layout/contextual_search_card_icon_view.xml",
@@ -1014,7 +999,6 @@
   "java/res/layout/toolbar_tablet.xml",
   "java/res/layout/top_sites_tile_view.xml",
   "java/res/layout/top_sites_tile_view_condensed.xml",
-  "java/res/layout/top_view.xml",
   "java/res/layout/update_menu_item.xml",
   "java/res/layout/updating_gms_progress_view.xml",
   "java/res/layout/url_action_container.xml",

diff --git a/chrome/android/chrome_java_sources.gni b/chrome/android/chrome_java_sources.gni
index 0b249ff..4c5ef00 100644
--- a/chrome/android/chrome_java_sources.gni
+++ b/chrome/android/chrome_java_sources.gni

@@ -345,17 +345,6 @@
   "java/src/org/chromium/chrome/browser/compositor/scene_layer/TabStripSceneLayer.java",
   "java/src/org/chromium/chrome/browser/consent_auditor/ConsentAuditorBridge.java",
   "java/src/org/chromium/chrome/browser/contacts_picker/ChromePickerAdapter.java",
-  "java/src/org/chromium/chrome/browser/contacts_picker/CompressContactIconsWorkerTask.java",
-  "java/src/org/chromium/chrome/browser/contacts_picker/ContactDetails.java",
-  "java/src/org/chromium/chrome/browser/contacts_picker/ContactView.java",
-  "java/src/org/chromium/chrome/browser/contacts_picker/ContactViewHolder.java",
-  "java/src/org/chromium/chrome/browser/contacts_picker/ContactsFetcherWorkerTask.java",
-  "java/src/org/chromium/chrome/browser/contacts_picker/ContactsPickerDialog.java",
-  "java/src/org/chromium/chrome/browser/contacts_picker/ContactsPickerToolbar.java",
-  "java/src/org/chromium/chrome/browser/contacts_picker/FetchIconWorkerTask.java",
-  "java/src/org/chromium/chrome/browser/contacts_picker/PickerAdapter.java",
-  "java/src/org/chromium/chrome/browser/contacts_picker/PickerCategoryView.java",
-  "java/src/org/chromium/chrome/browser/contacts_picker/TopView.java",
   "java/src/org/chromium/chrome/browser/content/ContentUtils.java",
   "java/src/org/chromium/chrome/browser/content_capture/ContentCaptureHistoryDeletionObserver.java",
   "java/src/org/chromium/chrome/browser/contextmenu/ChromeContextMenuItem.java",

diff --git a/chrome/android/chrome_test_java_sources.gni b/chrome/android/chrome_test_java_sources.gni
index d3593ac..c16460d 100644
--- a/chrome/android/chrome_test_java_sources.gni
+++ b/chrome/android/chrome_test_java_sources.gni

@@ -102,8 +102,6 @@
   "javatests/src/org/chromium/chrome/browser/compositor/layouts/MockLayoutHost.java",
   "javatests/src/org/chromium/chrome/browser/compositor/layouts/MockResourcesForLayout.java",
   "javatests/src/org/chromium/chrome/browser/compositor/overlays/strip/TabStripTest.java",
-  "javatests/src/org/chromium/chrome/browser/contacts_picker/ContactDetailsTest.java",
-  "javatests/src/org/chromium/chrome/browser/contacts_picker/ContactsPickerDialogTest.java",
   "javatests/src/org/chromium/chrome/browser/contextmenu/ContextMenuTest.java",
   "javatests/src/org/chromium/chrome/browser/contextmenu/RevampedContextMenuHeaderViewTest.java",
   "javatests/src/org/chromium/chrome/browser/contextmenu/RevampedContextMenuItemViewTest.java",

diff --git a/chrome/android/expectations/lint-baseline.xml b/chrome/android/expectations/lint-baseline.xml
index 421c798..0c9bf9a 100644
--- a/chrome/android/expectations/lint-baseline.xml
+++ b/chrome/android/expectations/lint-baseline.xml

@@ -2053,7 +2053,7 @@
         errorLine1="                android:clickable=&quot;true&quot;"
         errorLine2="                ~~~~~~~~~~~~~~~~~~~~~~~~">
         <location
-            file="../../chrome/android/java/res/layout/contacts_list_item_view.xml"
+            file="../../components/browser_ui/contacts_picker/android/java/res/layout/contacts_list_item_view.xml"
             line="48"
             column="17"/>
     </issue>
@@ -2064,7 +2064,7 @@
         errorLine1="                android:clickable=&quot;true&quot;"
         errorLine2="                ~~~~~~~~~~~~~~~~~~~~~~~~">
         <location
-            file="../../chrome/android/java/res/layout/contacts_list_item_view.xml"
+            file="../../components/browser_ui/contacts_picker/android/java/res/layout/contacts_list_item_view.xml"
             line="72"
             column="17"/>
     </issue>
@@ -2075,7 +2075,7 @@
         errorLine1="                android:clickable=&quot;true&quot;"
         errorLine2="                ~~~~~~~~~~~~~~~~~~~~~~~~">
         <location
-            file="../../chrome/android/java/res/layout/contacts_list_item_view.xml"
+            file="../../components/browser_ui/contacts_picker/android/java/res/layout/contacts_list_item_view.xml"
             line="96"
             column="17"/>
     </issue>

diff --git a/chrome/android/expectations/lint-suppressions.xml b/chrome/android/expectations/lint-suppressions.xml
index 924a5a5..d263818f 100644
--- a/chrome/android/expectations/lint-suppressions.xml
+++ b/chrome/android/expectations/lint-suppressions.xml

@@ -34,7 +34,7 @@
   </issue>
   <issue id="ContentDescription">
     <!--TODO(crbug.com/1044658): This suppression was added blindly, and needs investigated.-->
-    <ignore regexp="chrome/android/java/res/layout/contacts_list_item_view.xml"/>
+    <ignore regexp="components/browser_ui/contacts_picker/android/java/res/layout/contacts_list_item_view.xml"/>
     <!--TODO(crbug.com/1044658): This suppression was added blindly, and needs investigated.-->
     <ignore regexp="components/browser_ui/photo_picker/android/java/res/layout/photo_picker_dialog.xml"/>
     <!--TODO(crbug.com/1044658): This suppression was added blindly, and needs investigated.-->

diff --git a/chrome/android/feed/core/javatests/src/org/chromium/chrome/browser/feed/network_fetch/FeedNewTabPageCardInstrumentationTest.java b/chrome/android/feed/core/javatests/src/org/chromium/chrome/browser/feed/network_fetch/FeedNewTabPageCardInstrumentationTest.java
index 9a78b5d..934d639 100644
--- a/chrome/android/feed/core/javatests/src/org/chromium/chrome/browser/feed/network_fetch/FeedNewTabPageCardInstrumentationTest.java
+++ b/chrome/android/feed/core/javatests/src/org/chromium/chrome/browser/feed/network_fetch/FeedNewTabPageCardInstrumentationTest.java

@@ -15,7 +15,6 @@
 import org.junit.runner.RunWith;
 
 import org.chromium.base.test.util.CommandLineFlags;
-import org.chromium.base.test.util.DisabledTest;
 import org.chromium.base.test.util.Feature;
 import org.chromium.chrome.R;
 import org.chromium.chrome.browser.app.ChromeActivity;
@@ -58,7 +57,6 @@
     @Feature({"FeedNewTabPage", "WPRRecordReplayTest", "RenderTest"})
     @WPRArchiveDirectory("chrome/android/feed/core/javatests/src/org/chromium/chrome/"
             + "browser/feed/wpr_tests")
-    @DisabledTest(message = "https://crbug.com/1096656")
     public void
     launchNTP_withMultipleFeedCardsRendered() throws IOException, InterruptedException {
         mActivityTestRule.loadUrlInNewTab(UrlConstants.NTP_URL);

diff --git "a/chrome/android/feed/core/javatests/src/org/chromium/chrome/browser/feed/wpr_tests/FeedNewTabPageCardInstrumentationTest\043launchNTP_withMultipleFeedCardsRendered.wprgo.sha1" b/chrome/android/feed/core/javatests/src/org/chromium/chrome/browser/feed/wpr_tests/FeedNewTabPageCardInstrumentationTest__launchNTP_withMultipleFeedCardsRendered.wprgo.sha1
similarity index 100%
rename from "chrome/android/feed/core/javatests/src/org/chromium/chrome/browser/feed/wpr_tests/FeedNewTabPageCardInstrumentationTest\043launchNTP_withMultipleFeedCardsRendered.wprgo.sha1"
rename to chrome/android/feed/core/javatests/src/org/chromium/chrome/browser/feed/wpr_tests/FeedNewTabPageCardInstrumentationTest__launchNTP_withMultipleFeedCardsRendered.wprgo.sha1

diff --git a/chrome/android/java/src/org/chromium/chrome/browser/compositor/CompositorViewHolder.java b/chrome/android/java/src/org/chromium/chrome/browser/compositor/CompositorViewHolder.java
index 6f1de1c6..d178d16 100644
--- a/chrome/android/java/src/org/chromium/chrome/browser/compositor/CompositorViewHolder.java
+++ b/chrome/android/java/src/org/chromium/chrome/browser/compositor/CompositorViewHolder.java

@@ -71,6 +71,7 @@
 import org.chromium.components.browser_ui.widget.InsetObserverView;
 import org.chromium.components.content_capture.ContentCaptureConsumer;
 import org.chromium.components.content_capture.ContentCaptureConsumerImpl;
+import org.chromium.components.content_capture.ExperimentContentCaptureConsumer;
 import org.chromium.components.embedder_support.view.ContentView;
 import org.chromium.content_public.browser.WebContents;
 import org.chromium.ui.KeyboardVisibilityDelegate;
@@ -189,7 +190,9 @@
 
     // Indicates if ContentCaptureConsumer should be created, we only try to create it once.
     private boolean mShouldCreateContentCaptureConsumer = true;
-    private ContentCaptureConsumer mContentCaptureConsumer;
+    // TODO: (crbug.com/1119663) Move consumers out of this class while support multiple consumers.
+    private ArrayList<ContentCaptureConsumer> mContentCaptureConsumers =
+            new ArrayList<ContentCaptureConsumer>();
 
     private Set<Runnable> mOnCompositorLayoutCallbacks = new HashSet<>();
     private Set<Runnable> mDidSwapFrameCallbacks = new HashSet<>();
@@ -533,10 +536,10 @@
             mInsetObserverView.removeObserver(this);
             mInsetObserverView = null;
         }
-        if (mContentCaptureConsumer != null) {
-            mContentCaptureConsumer.onWebContentsChanged(null);
-            mContentCaptureConsumer = null;
+        for (ContentCaptureConsumer consumer : mContentCaptureConsumers) {
+            consumer.onWebContentsChanged(null);
         }
+        mContentCaptureConsumers.clear();
         if (mContentView != null) {
             mContentView.removeOnHierarchyChangeListener(this);
         }
@@ -1320,15 +1323,20 @@
 
         if (mTabVisible != null) initializeTab(mTabVisible);
 
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-            if (mShouldCreateContentCaptureConsumer) {
-                mContentCaptureConsumer =
+        if (mShouldCreateContentCaptureConsumer) {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                ContentCaptureConsumer consumer =
                         ContentCaptureConsumerImpl.create(getContext(), this, getWebContents());
-                mShouldCreateContentCaptureConsumer = false;
+                if (consumer != null) mContentCaptureConsumers.add(consumer);
             }
-        }
-        if (mContentCaptureConsumer != null) {
-            mContentCaptureConsumer.onWebContentsChanged(getWebContents());
+            ContentCaptureConsumer consumer =
+                    ExperimentContentCaptureConsumer.create(getWebContents());
+            if (consumer != null) mContentCaptureConsumers.add(consumer);
+            mShouldCreateContentCaptureConsumer = false;
+        } else {
+            for (ContentCaptureConsumer consumer : mContentCaptureConsumers) {
+                consumer.onWebContentsChanged(getWebContents());
+            }
         }
     }
 

diff --git a/chrome/android/java/src/org/chromium/chrome/browser/contacts_picker/ChromePickerAdapter.java b/chrome/android/java/src/org/chromium/chrome/browser/contacts_picker/ChromePickerAdapter.java
index fbf2e9f..5ab10951 100644
--- a/chrome/android/java/src/org/chromium/chrome/browser/contacts_picker/ChromePickerAdapter.java
+++ b/chrome/android/java/src/org/chromium/chrome/browser/contacts_picker/ChromePickerAdapter.java

@@ -17,6 +17,9 @@
 import org.chromium.chrome.browser.signin.DisplayableProfileData;
 import org.chromium.chrome.browser.signin.IdentityServicesProvider;
 import org.chromium.chrome.browser.signin.ProfileDataCache;
+import org.chromium.components.browser_ui.contacts_picker.ContactDetails;
+import org.chromium.components.browser_ui.contacts_picker.PickerAdapter;
+import org.chromium.components.browser_ui.contacts_picker.PickerCategoryView;
 import org.chromium.components.signin.AccountManagerFacade;
 import org.chromium.components.signin.AccountManagerFacadeProvider;
 import org.chromium.components.signin.base.CoreAccountInfo;

diff --git a/chrome/android/java/src/org/chromium/chrome/browser/init/ProcessInitializationHandler.java b/chrome/android/java/src/org/chromium/chrome/browser/init/ProcessInitializationHandler.java
index 0033809..ebb96f4 100644
--- a/chrome/android/java/src/org/chromium/chrome/browser/init/ProcessInitializationHandler.java
+++ b/chrome/android/java/src/org/chromium/chrome/browser/init/ProcessInitializationHandler.java

@@ -39,7 +39,6 @@
 import org.chromium.chrome.browser.banners.AppBannerManager;
 import org.chromium.chrome.browser.bookmarkswidget.BookmarkWidgetProvider;
 import org.chromium.chrome.browser.contacts_picker.ChromePickerAdapter;
-import org.chromium.chrome.browser.contacts_picker.ContactsPickerDialog;
 import org.chromium.chrome.browser.content_capture.ContentCaptureHistoryDeletionObserver;
 import org.chromium.chrome.browser.crash.CrashUploadCountStore;
 import org.chromium.chrome.browser.crash.LogcatExtractionRunnable;
@@ -79,6 +78,7 @@
 import org.chromium.chrome.browser.webapps.WebApkVersionManager;
 import org.chromium.chrome.browser.webapps.WebappRegistry;
 import org.chromium.components.background_task_scheduler.BackgroundTaskSchedulerFactory;
+import org.chromium.components.browser_ui.contacts_picker.ContactsPickerDialog;
 import org.chromium.components.browser_ui.photo_picker.PhotoPickerDialog;
 import org.chromium.components.browser_ui.share.ShareImageFileUtils;
 import org.chromium.components.browser_ui.util.ConversionUtils;

diff --git a/chrome/android/javatests/src/org/chromium/chrome/browser/contacts_picker/OWNERS b/chrome/android/javatests/src/org/chromium/chrome/browser/contacts_picker/OWNERS
deleted file mode 100644
index 478d375..0000000
--- a/chrome/android/javatests/src/org/chromium/chrome/browser/contacts_picker/OWNERS
+++ /dev/null

@@ -1 +0,0 @@
-file://chrome/android/java/src/org/chromium/chrome/browser/contacts_picker/OWNERS

diff --git a/chrome/browser/BUILD.gn b/chrome/browser/BUILD.gn
index 950ed71..05310cc7 100644
--- a/chrome/browser/BUILD.gn
+++ b/chrome/browser/BUILD.gn

@@ -2982,6 +2982,7 @@
       "//chrome/common:non_code_constants",
       "//chrome/services/media_gallery_util/public/cpp",
       "//components/autofill_assistant/browser",
+      "//components/browser_ui/contacts_picker/android",
       "//components/browser_ui/photo_picker/android",
       "//components/browser_ui/site_settings/android",
       "//components/browser_ui/sms/android",

diff --git a/chrome/browser/about_flags.cc b/chrome/browser/about_flags.cc
index 4eea407..19f41b8 100644
--- a/chrome/browser/about_flags.cc
+++ b/chrome/browser/about_flags.cc

@@ -2882,10 +2882,6 @@
     {"crostini-use-dlc", flag_descriptions::kCrostiniUseDlcName,
      flag_descriptions::kCrostiniUseDlcDescription, kOsCrOS,
      FEATURE_VALUE_TYPE(chromeos::features::kCrostiniUseDlc)},
-    {"terminal-system-app-legacy-settings",
-     flag_descriptions::kTerminalSystemAppLegacySettingsName,
-     flag_descriptions::kTerminalSystemAppLegacySettingsDescription, kOsCrOS,
-     FEATURE_VALUE_TYPE(features::kTerminalSystemAppLegacySettings)},
     {"pluginvm-show-camera-permissions",
      flag_descriptions::kPluginVmShowCameraPermissionsName,
      flag_descriptions::kPluginVmShowCameraPermissionsDescription, kOsCrOS,
@@ -4961,13 +4957,6 @@
          chromeos::assistant::features::kEnableStereoAudioInput)},
 #endif  // defined(OS_CHROMEOS)
 
-#if BUILDFLAG(ENABLE_PRINT_PREVIEW) && defined(OS_MAC)
-    {"enable-custom-mac-paper-sizes",
-     flag_descriptions::kEnableCustomMacPaperSizesName,
-     flag_descriptions::kEnableCustomMacPaperSizesDescription, kOsMac,
-     FEATURE_VALUE_TYPE(printing::features::kEnableCustomMacPaperSizes)},
-#endif
-
 #if defined(OS_WIN) || defined(OS_MAC) || defined(OS_LINUX) || \
     defined(OS_CHROMEOS)
     {"enable-reopen-tab-in-product-help",
@@ -5781,12 +5770,6 @@
      MULTI_VALUE_TYPE(kEnableCrOSActionRecorderChoices)},
 #endif  // defined(OS_CHROMEOS)
 
-#if !defined(OS_ANDROID)
-    {"mix-browser-type-tabs", flag_descriptions::kMixBrowserTypeTabsName,
-     flag_descriptions::kMixBrowserTypeTabsDescription, kOsDesktop,
-     FEATURE_VALUE_TYPE(features::kMixBrowserTypeTabs)},
-#endif  // !defined(OS_ANDROID)
-
 #if defined(OS_ANDROID)
     {"enable-games-hub", flag_descriptions::kGamesHubName,
      flag_descriptions::kGamesHubDescription, kOsAndroid,

diff --git a/chrome/browser/android/compositor/scene_layer/overscroll_scene_layer.cc b/chrome/browser/android/compositor/scene_layer/overscroll_scene_layer.cc
index eea61c9..78b71a5 100644
--- a/chrome/browser/android/compositor/scene_layer/overscroll_scene_layer.cc
+++ b/chrome/browser/android/compositor/scene_layer/overscroll_scene_layer.cc

@@ -18,8 +18,7 @@
     : SceneLayer(env, jobj),
       window_(ui::WindowAndroid::FromJavaWindowAndroid(jwindow)),
       glow_effect_(std::make_unique<ui::OverscrollGlow>(this)) {
-  if (window_->GetCompositor())
-    window_->AddObserver(this);
+  window_->AddObserver(this);
 }
 
 OverscrollSceneLayer::~OverscrollSceneLayer() {}

diff --git a/chrome/browser/chromeos/crostini/crostini_terminal.cc b/chrome/browser/chromeos/crostini/crostini_terminal.cc
index bf96dd22..6f5529b4 100644
--- a/chrome/browser/chromeos/crostini/crostini_terminal.cc
+++ b/chrome/browser/chromeos/crostini/crostini_terminal.cc

@@ -102,10 +102,6 @@
     return nullptr;
   }
   std::string path = "html/terminal_settings.html";
-  if (base::FeatureList::IsEnabled(
-          features::kTerminalSystemAppLegacySettings)) {
-    path = "html/nassh_preferences_editor.html";
-  }
   // Use an app pop window to host the settings page.
   params->disposition = WindowOpenDisposition::NEW_POPUP;
   return web_app::LaunchSystemWebApp(

diff --git a/chrome/browser/chromeos/extensions/autotest_private/autotest_private_api.h b/chrome/browser/chromeos/extensions/autotest_private/autotest_private_api.h
index 4e1a936..8e1c486 100644
--- a/chrome/browser/chromeos/extensions/autotest_private/autotest_private_api.h
+++ b/chrome/browser/chromeos/extensions/autotest_private/autotest_private_api.h

@@ -700,6 +700,7 @@
 
   // ui::ClipboardObserver
   void OnClipboardDataChanged() override;
+  void OnClipboardDataRead() override {}
 
   ScopedObserver<ui::ClipboardMonitor, ui::ClipboardObserver>
       clipboard_observer_;

diff --git a/chrome/browser/chromeos/file_system_provider/extension_provider.cc b/chrome/browser/chromeos/file_system_provider/extension_provider.cc
index 9014425b..9472baf 100644
--- a/chrome/browser/chromeos/file_system_provider/extension_provider.cc
+++ b/chrome/browser/chromeos/file_system_provider/extension_provider.cc

@@ -9,9 +9,13 @@
 #include <memory>
 #include <utility>
 
+#include "chrome/browser/apps/app_service/app_icon_source.h"
+#include "chrome/browser/apps/app_service/app_service_proxy.h"
+#include "chrome/browser/apps/app_service/app_service_proxy_factory.h"
 #include "chrome/browser/chromeos/file_system_provider/provided_file_system.h"
 #include "chrome/browser/chromeos/file_system_provider/throttled_file_system.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/common/chrome_features.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/common/permissions/permissions_data.h"
@@ -59,8 +63,9 @@
   if (!GetProvidingExtensionInfo(extension_id, &info, registry))
     return nullptr;
 
-  return std::unique_ptr<ProviderInterface>(
-      new ExtensionProvider(extension_id, info));
+  return std::make_unique<ExtensionProvider>(
+      Profile::FromBrowserContext(registry->browser_context()), extension_id,
+      info);
 }
 
 std::unique_ptr<ProvidedFileSystemInterface>
@@ -110,6 +115,7 @@
 }
 
 ExtensionProvider::ExtensionProvider(
+    Profile* profile,
     const extensions::ExtensionId& extension_id,
     const ProvidingExtensionInfo& info)
     : provider_id_(ProviderId::CreateFromExtensionId(extension_id)) {
@@ -118,6 +124,29 @@
   capabilities_.multiple_mounts = info.capabilities.multiple_mounts();
   capabilities_.source = info.capabilities.source();
   name_ = info.name;
+
+  if (base::FeatureList::IsEnabled(features::kAppServiceAdaptiveIcon) &&
+      apps::AppServiceProxyFactory::IsAppServiceAvailableForProfile(profile)) {
+    auto* AppServiceProxy =
+        apps::AppServiceProxyFactory::GetForProfile(profile);
+
+    // AppService loading apps from extensions might be slow due to async. Even
+    // if the app doesn't exist in AppRegistryCache, it might be added later. So
+    // we still observe the AppRegistry to catch the app update information.
+    Observe(&AppServiceProxy->AppRegistryCache());
+
+    if (AppServiceProxy->AppRegistryCache().GetAppType(
+            provider_id_.GetExtensionId()) != apps::mojom::AppType::kUnknown) {
+      icon_set_.SetIcon(
+          IconSet::IconSize::SIZE_16x16,
+          apps::AppIconSource::GetIconURL(provider_id_.GetExtensionId(), 16));
+      icon_set_.SetIcon(
+          IconSet::IconSize::SIZE_32x32,
+          apps::AppIconSource::GetIconURL(provider_id_.GetExtensionId(), 32));
+      return;
+    }
+  }
+
   icon_set_.SetIcon(IconSet::IconSize::SIZE_16x16,
                     GURL(std::string("chrome://extension-icon/") +
                          provider_id_.GetExtensionId() + "/16/1"));
@@ -128,5 +157,24 @@
 
 ExtensionProvider::~ExtensionProvider() = default;
 
+void ExtensionProvider::OnAppUpdate(const apps::AppUpdate& update) {
+  if (update.AppId() != provider_id_.GetExtensionId() ||
+      !update.IconKeyChanged()) {
+    return;
+  }
+
+  icon_set_.SetIcon(
+      IconSet::IconSize::SIZE_16x16,
+      apps::AppIconSource::GetIconURL(provider_id_.GetExtensionId(), 16));
+  icon_set_.SetIcon(
+      IconSet::IconSize::SIZE_32x32,
+      apps::AppIconSource::GetIconURL(provider_id_.GetExtensionId(), 32));
+}
+
+void ExtensionProvider::OnAppRegistryCacheWillBeDestroyed(
+    apps::AppRegistryCache* cache) {
+  Observe(nullptr);
+}
+
 }  // namespace file_system_provider
 }  // namespace chromeos

diff --git a/chrome/browser/chromeos/file_system_provider/extension_provider.h b/chrome/browser/chromeos/file_system_provider/extension_provider.h
index 6855b95..bc6f654 100644
--- a/chrome/browser/chromeos/file_system_provider/extension_provider.h
+++ b/chrome/browser/chromeos/file_system_provider/extension_provider.h

@@ -12,6 +12,7 @@
 #include "chrome/browser/chromeos/file_system_provider/provided_file_system_info.h"
 #include "chrome/browser/chromeos/file_system_provider/provided_file_system_interface.h"
 #include "chrome/browser/chromeos/file_system_provider/provider_interface.h"
+#include "components/services/app_service/public/cpp/app_registry_cache.h"
 #include "extensions/common/extension_id.h"
 
 class Profile;
@@ -33,8 +34,12 @@
   extensions::FileSystemProviderCapabilities capabilities;
 };
 
-class ExtensionProvider : public ProviderInterface {
+class ExtensionProvider : public ProviderInterface,
+                          public apps::AppRegistryCache::Observer {
  public:
+  ExtensionProvider(Profile* profile,
+                    const extensions::ExtensionId& extension_id,
+                    const ProvidingExtensionInfo& info);
   ~ExtensionProvider() override;
 
   // Returns a provider instance for the specified extension. If the extension
@@ -54,8 +59,10 @@
   bool RequestMount(Profile* profile) override;
 
  private:
-  ExtensionProvider(const extensions::ExtensionId& extension_id,
-                    const ProvidingExtensionInfo& info);
+  // apps::AppRegistryCache::Observer overrides:
+  void OnAppUpdate(const apps::AppUpdate& update) override;
+  void OnAppRegistryCacheWillBeDestroyed(
+      apps::AppRegistryCache* cache) override;
 
   ProviderId provider_id_;
   Capabilities capabilities_;

diff --git a/chrome/browser/chromeos/login/demo_mode/demo_setup_browsertest.cc b/chrome/browser/chromeos/login/demo_mode/demo_setup_browsertest.cc
index ff76b74..4bbb183 100644
--- a/chrome/browser/chromeos/login/demo_mode/demo_setup_browsertest.cc
+++ b/chrome/browser/chromeos/login/demo_mode/demo_setup_browsertest.cc

@@ -514,8 +514,16 @@
   EXPECT_TRUE(IsConfirmationDialogShown());
 }
 
+// TODO(https://crbug.com/1121422): Flaky on ChromeOS ASAN.
+#if defined(ADDRESS_SANITIZER)
+#define MAYBE_DoNotInvokeWithNonConsecutiveTaps \
+  DISABLED_DoNotInvokeWithNonConsecutiveTaps
+#else
+#define MAYBE_DoNotInvokeWithNonConsecutiveTaps \
+  DoNotInvokeWithNonConsecutiveTaps
+#endif
 IN_PROC_BROWSER_TEST_F(DemoSetupArcSupportedTest,
-                       DoNotInvokeWithNonConsecutiveTaps) {
+                       MAYBE_DoNotInvokeWithNonConsecutiveTaps) {
   // Use fake time to avoid flakiness.
   const base::Time kFakeTime = base::Time::UnixEpoch();
   SetFakeTimeForMultiTapDetector(kFakeTime);
@@ -856,7 +864,14 @@
   EXPECT_FALSE(StartupUtils::IsDeviceRegistered());
 }
 
-IN_PROC_BROWSER_TEST_F(DemoSetupArcSupportedTest, OfflineDemoModeUnavailable) {
+// TODO(https://crbug.com/1121422): Flaky on ChromeOS ASAN.
+#if defined(ADDRESS_SANITIZER)
+#define MAYBE_OfflineDemoModeUnavailable DISABLED_OfflineDemoModeUnavailable
+#else
+#define MAYBE_OfflineDemoModeUnavailable OfflineDemoModeUnavailable
+#endif
+IN_PROC_BROWSER_TEST_F(DemoSetupArcSupportedTest,
+                       MAYBE_OfflineDemoModeUnavailable) {
   SimulateNetworkDisconnected();
 
   InvokeDemoModeWithAccelerator();
@@ -936,8 +951,14 @@
   EXPECT_TRUE(StartupUtils::IsDeviceRegistered());
 }
 
+// TODO(https://crbug.com/1121422): Flaky on ChromeOS ASAN.
+#if defined(ADDRESS_SANITIZER)
+#define MAYBE_OfflineSetupFlowErrorDefault DISABLED_OfflineSetupFlowErrorDefault
+#else
+#define MAYBE_OfflineSetupFlowErrorDefault OfflineSetupFlowErrorDefault
+#endif
 IN_PROC_BROWSER_TEST_F(DemoSetupArcSupportedTest,
-                       OfflineSetupFlowErrorDefault) {
+                       MAYBE_OfflineSetupFlowErrorDefault) {
   // Simulate offline setup failure.
   enrollment_helper_.ExpectOfflineEnrollmentError(
       policy::EnrollmentStatus::ForStatus(
@@ -1002,8 +1023,16 @@
   EXPECT_FALSE(StartupUtils::IsDeviceRegistered());
 }
 
+// TODO(https://crbug.com/1121422): Flaky on ChromeOS ASAN.
+#if defined(ADDRESS_SANITIZER)
+#define MAYBE_OfflineSetupFlowErrorPowerwashRequired \
+  DISABLED_OfflineSetupFlowErrorPowerwashRequired
+#else
+#define MAYBE_OfflineSetupFlowErrorPowerwashRequired \
+  OfflineSetupFlowErrorPowerwashRequired
+#endif
 IN_PROC_BROWSER_TEST_F(DemoSetupArcSupportedTest,
-                       OfflineSetupFlowErrorPowerwashRequired) {
+                       MAYBE_OfflineSetupFlowErrorPowerwashRequired) {
   // Simulate offline setup failure.
   enrollment_helper_.ExpectOfflineEnrollmentError(
       policy::EnrollmentStatus::ForLockError(

diff --git a/chrome/browser/flag-metadata.json b/chrome/browser/flag-metadata.json
index e2f5324..3a1513f2 100644
--- a/chrome/browser/flag-metadata.json
+++ b/chrome/browser/flag-metadata.json

@@ -3036,11 +3036,6 @@
     "expiry_milestone": 83
   },
   {
-    "name": "mix-browser-type-tabs",
-    "owners": [ "joelhockey", "tbuckley" ],
-    "expiry_milestone": 85
-  },
-  {
     "name": "mixed-forms-disable-autofill",
     "owners": [ "carlosil" ],
     "expiry_milestone": 88
@@ -4004,7 +3999,7 @@
   {
     "name": "share-button-in-top-toolbar",
     "owners": [ "jeffreycohen" ],
-    "expiry_milestone": 86
+    "expiry_milestone": 88
   },
   {
     "name": "shared-clipboard-ui",
@@ -4279,11 +4274,6 @@
     "expiry_milestone": 90
   },
   {
-    "name": "terminal-system-app-legacy-settings",
-    "owners": [ "joelhockey", "benwells", "//chrome/browser/chromeos/guest_os/OWNERS" ],
-    "expiry_milestone": 85
-  },
-  {
     "name": "textfield-focus-on-tap-up",
     "owners": [ "collinbaker" ],
     "expiry_milestone": 86

diff --git a/chrome/browser/flag_descriptions.cc b/chrome/browser/flag_descriptions.cc
index 6df4811..efca5ff 100644
--- a/chrome/browser/flag_descriptions.cc
+++ b/chrome/browser/flag_descriptions.cc

@@ -1366,11 +1366,6 @@
     "Have the Media Router connect to Cast devices on all IP addresses, not "
     "just RFC1918/RFC4193 private addresses.";
 
-const char kMixBrowserTypeTabsName[] = "Mix browser type tabs";
-const char kMixBrowserTypeTabsDescription[] =
-    "Allows tabs to be dragged between any browsers that support tabs, "
-    "including apps";
-
 const char kMixedFormsDisableAutofillName[] =
     "Disable autofill for mixed forms";
 const char kMixedFormsDisableAutofillDescription[] =
@@ -3491,10 +3486,6 @@
 const char kImmersiveFullscreenDescription[] =
     "Automatically hide and show the toolbar in fullscreen.";
 
-const char kEnableCustomMacPaperSizesName[] = "Enable custom paper sizes";
-const char kEnableCustomMacPaperSizesDescription[] =
-    "Allow use of custom paper sizes in Print Preview.";
-
 const char kMacSyscallSandboxName[] = "Mac Syscall Filtering Sandbox";
 const char kMacSyscallSandboxDescription[] =
     "Controls whether the macOS sandbox filters syscalls.";
@@ -4280,11 +4271,6 @@
 const char kSyncWifiConfigurationsDescription[] =
     "Enables the option to sync Wi-Fi network configurations with Chrome Sync.";
 
-const char kTerminalSystemAppLegacySettingsName[] =
-    "Terminal System App Legacy Settings";
-const char kTerminalSystemAppLegacySettingsDescription[] =
-    "Use the legacy settings page for Terminal System App.";
-
 const char kPluginVmShowCameraPermissionsName[] =
     "Show Plugin VM camera permissions";
 const char kPluginVmShowCameraPermissionsDescription[] =

diff --git a/chrome/browser/flag_descriptions.h b/chrome/browser/flag_descriptions.h
index 81ad470..94ec43c 100644
--- a/chrome/browser/flag_descriptions.h
+++ b/chrome/browser/flag_descriptions.h

@@ -804,9 +804,6 @@
 extern const char kMediaRouterCastAllowAllIPsName[];
 extern const char kMediaRouterCastAllowAllIPsDescription[];
 
-extern const char kMixBrowserTypeTabsName[];
-extern const char kMixBrowserTypeTabsDescription[];
-
 extern const char kMixedFormsDisableAutofillName[];
 extern const char kMixedFormsDisableAutofillDescription[];
 
@@ -2012,9 +2009,6 @@
 extern const char kImmersiveFullscreenName[];
 extern const char kImmersiveFullscreenDescription[];
 
-extern const char kEnableCustomMacPaperSizesName[];
-extern const char kEnableCustomMacPaperSizesDescription[];
-
 extern const char kMacSyscallSandboxName[];
 extern const char kMacSyscallSandboxDescription[];
 
@@ -2293,9 +2287,6 @@
 extern const char kEnableQuickAnswersTextAnnotatorName[];
 extern const char kEnableQuickAnswersTextAnnotatorDescription[];
 
-extern const char kTerminalSystemAppLegacySettingsName[];
-extern const char kTerminalSystemAppLegacySettingsDescription[];
-
 extern const char kPluginVmShowCameraPermissionsName[];
 extern const char kPluginVmShowCameraPermissionsDescription[];
 

diff --git a/chrome/browser/flags/android/chrome_feature_list.cc b/chrome/browser/flags/android/chrome_feature_list.cc
index 17be1584..93ae78b 100644
--- a/chrome/browser/flags/android/chrome_feature_list.cc
+++ b/chrome/browser/flags/android/chrome_feature_list.cc

@@ -139,7 +139,6 @@
     &kChromeSmartSelection,
     &kCommandLineOnNonRooted,
     &kConditionalTabStripAndroid,
-    &kContactsPickerSelectAll,
     &kContentIndexingDownloadHome,
     &kContentIndexingNTP,
     &kContentSuggestionsScrollToLoad,
@@ -400,9 +399,6 @@
 const base::Feature kCommandLineOnNonRooted{"CommandLineOnNonRooted",
                                             base::FEATURE_DISABLED_BY_DEFAULT};
 
-const base::Feature kContactsPickerSelectAll{"ContactsPickerSelectAll",
-                                             base::FEATURE_DISABLED_BY_DEFAULT};
-
 const base::Feature kContentIndexingDownloadHome{
     "ContentIndexingDownloadHome", base::FEATURE_ENABLED_BY_DEFAULT};
 

diff --git a/chrome/browser/flags/android/chrome_feature_list.h b/chrome/browser/flags/android/chrome_feature_list.h
index 6eed644..29a99b8 100644
--- a/chrome/browser/flags/android/chrome_feature_list.h
+++ b/chrome/browser/flags/android/chrome_feature_list.h

@@ -48,7 +48,6 @@
 extern const base::Feature kChromeSmartSelection;
 extern const base::Feature kCommandLineOnNonRooted;
 extern const base::Feature kConditionalTabStripAndroid;
-extern const base::Feature kContactsPickerSelectAll;
 extern const base::Feature kContentIndexingDownloadHome;
 extern const base::Feature kContentIndexingNTP;
 extern const base::Feature kContextMenuCopyImage;

diff --git a/chrome/browser/nearby_sharing/contacts/fake_nearby_share_contact_manager.cc b/chrome/browser/nearby_sharing/contacts/fake_nearby_share_contact_manager.cc
index b504677c..94e8eb2 100644
--- a/chrome/browser/nearby_sharing/contacts/fake_nearby_share_contact_manager.cc
+++ b/chrome/browser/nearby_sharing/contacts/fake_nearby_share_contact_manager.cc

@@ -20,18 +20,6 @@
 
 FakeNearbyShareContactManager::~FakeNearbyShareContactManager() = default;
 
-void FakeNearbyShareContactManager::NotifyObservers(
-    bool contacts_list_changed,
-    bool contacts_added_to_allowlist,
-    bool contacts_removed_from_allowlist,
-    const std::set<std::string>& allowed_contact_ids,
-    const base::Optional<std::vector<nearbyshare::proto::ContactRecord>>&
-        contacts) {
-  NotifyContactsUpdated(contacts_list_changed, contacts_added_to_allowlist,
-                        contacts_removed_from_allowlist, allowed_contact_ids,
-                        contacts);
-}
-
 void FakeNearbyShareContactManager::DownloadContacts(
     bool only_download_if_changed) {
   download_contacts_calls_.push_back(only_download_if_changed);

diff --git a/chrome/browser/nearby_sharing/contacts/fake_nearby_share_contact_manager.h b/chrome/browser/nearby_sharing/contacts/fake_nearby_share_contact_manager.h
index 8e2ae96..02b3a988 100644
--- a/chrome/browser/nearby_sharing/contacts/fake_nearby_share_contact_manager.h
+++ b/chrome/browser/nearby_sharing/contacts/fake_nearby_share_contact_manager.h

@@ -17,8 +17,10 @@
 
 // A fake implementation of NearbyShareContactManager, along with a fake
 // factory, to be used in tests. Stores parameters input into
-// NearbyShareContactManager method calls. Provides a method to notify
-// observers.
+// NearbyShareContactManager method calls. Use the notification methods from the
+// base class--NotifyAllowlistChanged(), NotifyContactsDownloaded(),
+// NotifyContactsUploaded()--to alert observers of changes; these methods are
+// made public in this fake class.
 class FakeNearbyShareContactManager : public NearbyShareContactManager {
  public:
   // Factory that creates FakeNearbyShareContactManager instances. Use in
@@ -45,14 +47,6 @@
   FakeNearbyShareContactManager();
   ~FakeNearbyShareContactManager() override;
 
-  void NotifyObservers(
-      bool contacts_list_changed,
-      bool contacts_added_to_allowlist,
-      bool contacts_removed_from_allowlist,
-      const std::set<std::string>& allowed_contact_ids,
-      const base::Optional<std::vector<nearbyshare::proto::ContactRecord>>&
-          contacts);
-
   // Returns inputs of all DownloadContacts() calls.
   const std::vector<bool>& download_contacts_calls() const {
     return download_contacts_calls_;
@@ -63,6 +57,11 @@
     return set_allowed_contacts_calls_;
   }
 
+  // Make protected methods from base class public in this fake class.
+  using NearbyShareContactManager::NotifyAllowlistChanged;
+  using NearbyShareContactManager::NotifyContactsDownloaded;
+  using NearbyShareContactManager::NotifyContactsUploaded;
+
  private:
   // NearbyShareContactsManager:
   void DownloadContacts(bool only_download_if_changed) override;

diff --git a/chrome/browser/nearby_sharing/contacts/nearby_share_contact_manager.cc b/chrome/browser/nearby_sharing/contacts/nearby_share_contact_manager.cc
index 728724d..02be5f0 100644
--- a/chrome/browser/nearby_sharing/contacts/nearby_share_contact_manager.cc
+++ b/chrome/browser/nearby_sharing/contacts/nearby_share_contact_manager.cc

@@ -28,16 +28,26 @@
   OnStop();
 }
 
-void NearbyShareContactManager::NotifyContactsUpdated(
-    bool contacts_list_changed,
-    bool contacts_added_to_allowlist,
-    bool contacts_removed_from_allowlist,
-    const std::set<std::string>& allowed_contact_ids,
-    const base::Optional<std::vector<nearbyshare::proto::ContactRecord>>&
-        contacts) {
+void NearbyShareContactManager::NotifyAllowlistChanged(
+    bool were_contacts_added_to_allowlist,
+    bool were_contacts_removed_from_allowlist) {
   for (auto& observer : observers_) {
-    observer.OnContactsUpdated(
-        contacts_list_changed, contacts_added_to_allowlist,
-        contacts_removed_from_allowlist, allowed_contact_ids, contacts);
+    observer.OnAllowlistChanged(were_contacts_added_to_allowlist,
+                                were_contacts_removed_from_allowlist);
+  }
+}
+
+void NearbyShareContactManager::NotifyContactsDownloaded(
+    const std::set<std::string>& allowed_contact_ids,
+    const std::vector<nearbyshare::proto::ContactRecord>& contacts) {
+  for (auto& observer : observers_) {
+    observer.OnContactsDownloaded(allowed_contact_ids, contacts);
+  }
+}
+
+void NearbyShareContactManager::NotifyContactsUploaded(
+    bool did_contacts_change_since_last_upload) {
+  for (auto& observer : observers_) {
+    observer.OnContactsUploaded(did_contacts_change_since_last_upload);
   }
 }

diff --git a/chrome/browser/nearby_sharing/contacts/nearby_share_contact_manager.h b/chrome/browser/nearby_sharing/contacts/nearby_share_contact_manager.h
index 35647ac..461b804 100644
--- a/chrome/browser/nearby_sharing/contacts/nearby_share_contact_manager.h
+++ b/chrome/browser/nearby_sharing/contacts/nearby_share_contact_manager.h

@@ -16,22 +16,31 @@
 #include "base/optional.h"
 #include "chrome/browser/nearby_sharing/proto/rpc_resources.pb.h"
 
-// The Nearby Share contacts manager interfaces with the Nearby server to 1)
-// download the user's contacts and 2) upload the user-input list of allowed
-// contacts for selected-contacts visibility mode. All contact data and update
-// notifications are conveyed to observers via OnContactsUpdated(); the manager
-// does not return data directly from function calls.
+// The Nearby Share contacts manager interfaces with the Nearby server in the
+// following ways:
+//   1) The user's contacts are downloaded from People API, using the Nearby
+//   server as a proxy.
+//   2) All of the user's contacts are uploaded to Nearby server, along with an
+//   indication of what contacts are allowed for selected-contacts visibility
+//   mode. The Nearby server will distribute all-contacts and selected-contacts
+//   visibility certificates accordingly. For privacy reasons, the Nearby server
+//   needs to explicitly receive the list of contacts from the device instead of
+//   pulling them directly from People API.
+//
+// All contact data and update notifications are conveyed via observer methods;
+// the manager does not return data directly from function calls.
 class NearbyShareContactManager {
  public:
   class Observer : public base::CheckedObserver {
    public:
-    virtual void OnContactsUpdated(
-        bool contacts_list_changed,
-        bool contacts_added_to_allowlist,
-        bool contacts_removed_from_allowlist,
+    virtual void OnAllowlistChanged(
+        bool were_contacts_added_to_allowlist,
+        bool were_contacts_removed_from_allowlist) = 0;
+    virtual void OnContactsDownloaded(
         const std::set<std::string>& allowed_contact_ids,
-        const base::Optional<std::vector<nearbyshare::proto::ContactRecord>>&
-            contacts) = 0;
+        const std::vector<nearbyshare::proto::ContactRecord>& contacts) = 0;
+    virtual void OnContactsUploaded(
+        bool did_contacts_change_since_last_upload) = 0;
   };
 
   NearbyShareContactManager();
@@ -46,11 +55,11 @@
   bool is_running() { return is_running_; }
 
   // Makes RPC calls to check if the user's contact list has changed since the
-  // last call to the server. If it changed or if |only_download_if_changed| is
-  // false, the contact list is downloaded from the server. The list of allowed
-  // contacts is reconciled with the newly downloaded contacts. These RPC calls
-  // are also scheduled periodically. The results are sent to observers via
-  // OnContactsUpdated().
+  // last contact upload via the UpdateDevice RPC. If it changed or if
+  // |only_download_if_changed| is false, the contact list is downloaded from
+  // the server. The locally persisted list of allowed contacts is reconciled
+  // with the newly downloaded contacts. These RPC calls are also scheduled
+  // periodically. The results are sent to observers via OnContactsDownloaded().
   virtual void DownloadContacts(bool only_download_if_changed) = 0;
 
   // Assigns the set of contacts that the local device allows sharing with when
@@ -58,7 +67,7 @@
   // all-contacts visibility mode.) The allowed contact list determines what
   // contacts receive the local device's "selected-contacts" visibility public
   // certificates. Changes to the allowlist will trigger an RPC call. Observers
-  // are notified of any changes to the allowlist via OnContactsUpdated().
+  // are notified of any changes to the allowlist via OnAllowlistChanged().
   virtual void SetAllowedContacts(
       const std::set<std::string>& allowed_contact_ids) = 0;
 
@@ -66,13 +75,12 @@
   virtual void OnStart() = 0;
   virtual void OnStop() = 0;
 
-  void NotifyContactsUpdated(
-      bool contacts_list_changed,
-      bool contacts_added_to_allowlist,
-      bool contacts_removed_from_allowlist,
+  void NotifyAllowlistChanged(bool were_contacts_added_to_allowlist,
+                              bool were_contacts_removed_from_allowlist);
+  void NotifyContactsDownloaded(
       const std::set<std::string>& allowed_contact_ids,
-      const base::Optional<std::vector<nearbyshare::proto::ContactRecord>>&
-          contacts);
+      const std::vector<nearbyshare::proto::ContactRecord>& contacts);
+  void NotifyContactsUploaded(bool did_contacts_change_since_last_upload);
 
  private:
   bool is_running_ = false;

diff --git a/chrome/browser/prerender/isolated/isolated_prerender_browsertest.cc b/chrome/browser/prerender/isolated/isolated_prerender_browsertest.cc
index 9600dd8..1e948b5 100644
--- a/chrome/browser/prerender/isolated/isolated_prerender_browsertest.cc
+++ b/chrome/browser/prerender/isolated/isolated_prerender_browsertest.cc

@@ -307,6 +307,38 @@
       new ClientCertStoreStub(std::move(cert_identity_list)));
 }
 
+class CustomProbeOverrideDelegate
+    : public IsolatedPrerenderOriginProber::ProbeURLOverrideDelegate {
+ public:
+  explicit CustomProbeOverrideDelegate(const GURL& override_url)
+      : url_(override_url) {}
+  ~CustomProbeOverrideDelegate() = default;
+
+  GURL OverrideProbeURL(const GURL& url) override { return url_; }
+
+ private:
+  GURL url_;
+};
+
+class TestServerConnectionCounter
+    : public net::test_server::EmbeddedTestServerConnectionListener {
+ public:
+  TestServerConnectionCounter() = default;
+  ~TestServerConnectionCounter() override = default;
+
+  size_t count() const { return count_; }
+
+ private:
+  void ReadFromSocket(const net::StreamSocket& connection, int rv) override {}
+  std::unique_ptr<net::StreamSocket> AcceptedSocket(
+      std::unique_ptr<net::StreamSocket> socket) override {
+    count_++;
+    return socket;
+  }
+
+  size_t count_ = 0;
+};
+
 }  // namespace
 
 // Occasional flakes on Windows (https://crbug.com/1045971).
@@ -319,8 +351,7 @@
 class IsolatedPrerenderBrowserTest
     : public InProcessBrowserTest,
       public prerender::PrerenderHandle::Observer,
-      public net::test_server::EmbeddedTestServerConnectionListener,
-      public IsolatedPrerenderOriginProber::ProbeURLOverrideDelegate {
+      public net::test_server::EmbeddedTestServerConnectionListener {
  public:
   IsolatedPrerenderBrowserTest() {
     origin_server_ = std::make_unique<net::EmbeddedTestServer>(
@@ -402,10 +433,6 @@
     host_resolver()->AddSimulatedFailure("baddnsprobe.a.test");
   }
 
-  GURL OverrideProbeURL(const GURL& url) override {
-    return GURL("https://baddnsprobe.a.test");
-  }
-
   void SetUpCommandLine(base::CommandLine* cmd) override {
     InProcessBrowserTest::SetUpCommandLine(cmd);
     // For the proxy.
@@ -1914,6 +1941,20 @@
   base::test::ScopedFeatureList scoped_feature_list_;
 };
 
+class ProbingEnabled_CanaryOff_TLS_IsolatedPrerenderBrowserTest
+    : public IsolatedPrerenderBrowserTest {
+ public:
+  void SetFeatures() override {
+    IsolatedPrerenderBrowserTest::SetFeatures();
+    scoped_feature_list_.InitAndEnableFeatureWithParameters(
+        features::kIsolatePrerendersMustProbeOrigin,
+        {{"do_canary", "false"}, {"probe_type", "tls"}});
+  }
+
+ private:
+  base::test::ScopedFeatureList scoped_feature_list_;
+};
+
 class ProbingEnabled_CanaryOn_CanaryGood_IsolatedPrerenderBrowserTest
     : public IsolatedPrerenderBrowserTest {
  public:
@@ -2179,7 +2220,9 @@
 
   IsolatedPrerenderService* service =
       IsolatedPrerenderServiceFactory::GetForProfile(browser()->profile());
-  service->origin_prober()->SetProbeURLOverrideDelegateOverrideForTesting(this);
+  CustomProbeOverrideDelegate delegate(GURL("https://baddnsprobe.a.test"));
+  service->origin_prober()->SetProbeURLOverrideDelegateOverrideForTesting(
+      &delegate);
 
   IsolatedPrerenderTabHelper* tab_helper =
       IsolatedPrerenderTabHelper::FromWebContents(GetWebContents());
@@ -2242,6 +2285,176 @@
   EXPECT_NE(base::nullopt, probe_latency_ms);
 }
 
+IN_PROC_BROWSER_TEST_F(
+    ProbingEnabled_CanaryOff_TLS_IsolatedPrerenderBrowserTest,
+    DISABLE_ON_WIN_MAC_CHROMEOS(ProbeGood)) {
+  SetDataSaverEnabled(true);
+  GURL starting_page = GetOriginServerURL("/simple.html");
+  ui_test_utils::NavigateToURL(browser(), starting_page);
+  WaitForUpdatedCustomProxyConfig();
+
+  // Setup a local probing server so we can watch its accepted socket count.
+  TestServerConnectionCounter probe_counter;
+  net::EmbeddedTestServer probing_server(net::EmbeddedTestServer::TYPE_HTTPS);
+  probing_server.SetSSLConfig(net::EmbeddedTestServer::CERT_TEST_NAMES);
+  probing_server.SetConnectionListener(&probe_counter);
+  ASSERT_TRUE(probing_server.Start());
+
+  // Override the probing URL to always hit this server.
+  IsolatedPrerenderService* service =
+      IsolatedPrerenderServiceFactory::GetForProfile(browser()->profile());
+  CustomProbeOverrideDelegate delegate(probing_server.GetURL("a.test", "/"));
+  service->origin_prober()->SetProbeURLOverrideDelegateOverrideForTesting(
+      &delegate);
+
+  IsolatedPrerenderTabHelper* tab_helper =
+      IsolatedPrerenderTabHelper::FromWebContents(GetWebContents());
+
+  GURL eligible_link = GetOriginServerURL("/title2.html");
+
+  TestTabHelperObserver tab_helper_observer(tab_helper);
+  tab_helper_observer.SetExpectedSuccessfulURLs({eligible_link});
+
+  base::RunLoop run_loop;
+  tab_helper_observer.SetOnPrefetchSuccessfulClosure(run_loop.QuitClosure());
+
+  GURL doc_url("https://www.google.com/search?q=test");
+  MakeNavigationPrediction(doc_url, {eligible_link});
+
+  // This run loop will quit when all the prefetch responses have been
+  // successfully done and processed.
+  run_loop.Run();
+
+  size_t starting_origin_request_count = OriginServerRequestCount();
+  ASSERT_EQ(0U, probe_counter.count());
+  ui_test_utils::NavigateToURL(browser(), eligible_link);
+
+  EXPECT_EQ(1U, probe_counter.count());
+
+  // No full requests should have hit the server.
+  EXPECT_EQ(starting_origin_request_count, OriginServerRequestCount());
+
+  EXPECT_EQ(base::UTF8ToUTF16("Title Of Awesomeness"),
+            GetWebContents()->GetTitle());
+
+  ASSERT_TRUE(tab_helper->after_srp_metrics());
+  ASSERT_TRUE(tab_helper->after_srp_metrics()->prefetch_status_.has_value());
+  // 1 is the value of "prefetch used, probe success". The test does not
+  // reference the enum directly to ensure that casting the enum to an int went
+  // cleanly, and to provide an extra review point if the value should ever
+  // accidentally change in the future, which it never should.
+  EXPECT_EQ(1, static_cast<int>(
+                   tab_helper->after_srp_metrics()->prefetch_status_.value()));
+
+  base::Optional<base::TimeDelta> probe_latency =
+      tab_helper->after_srp_metrics()->probe_latency_;
+  ASSERT_TRUE(probe_latency.has_value());
+  EXPECT_GT(probe_latency.value(), base::TimeDelta());
+
+  // Navigate again to trigger UKM recording.
+  ui_test_utils::NavigateToURL(browser(), GURL("about:blank"));
+  base::RunLoop().RunUntilIdle();
+
+  // 1 = |PrefetchStatus::kPrefetchUsedProbeSuccess|.
+  EXPECT_EQ(base::Optional<int64_t>(1),
+            GetUKMMetric(eligible_link,
+                         ukm::builders::PrefetchProxy_AfterSRPClick::kEntryName,
+                         ukm::builders::PrefetchProxy_AfterSRPClick::
+                             kSRPClickPrefetchStatusName));
+  // The actual probe latency is hard to deterministically test for. Just make
+  // sure it is set within reasonable bounds.
+  base::Optional<int64_t> probe_latency_ms = GetUKMMetric(
+      eligible_link, ukm::builders::PrefetchProxy_AfterSRPClick::kEntryName,
+      ukm::builders::PrefetchProxy_AfterSRPClick::kProbeLatencyMsName);
+  EXPECT_NE(base::nullopt, probe_latency_ms);
+}
+
+IN_PROC_BROWSER_TEST_F(
+    ProbingEnabled_CanaryOff_TLS_IsolatedPrerenderBrowserTest,
+    DISABLE_ON_WIN_MAC_CHROMEOS(ProbeBad)) {
+  SetDataSaverEnabled(true);
+  GURL starting_page = GetOriginServerURL("/simple.html");
+  ui_test_utils::NavigateToURL(browser(), starting_page);
+  WaitForUpdatedCustomProxyConfig();
+
+  // Setup a local probing server so we can watch its accepted socket count.
+  TestServerConnectionCounter probe_counter;
+  net::EmbeddedTestServer probing_server(net::EmbeddedTestServer::TYPE_HTTPS);
+  probing_server.SetSSLConfig(net::EmbeddedTestServer::CERT_BAD_VALIDITY);
+  probing_server.SetConnectionListener(&probe_counter);
+  ASSERT_TRUE(probing_server.Start());
+
+  // Override the probing URL to always hit this server.
+  IsolatedPrerenderService* service =
+      IsolatedPrerenderServiceFactory::GetForProfile(browser()->profile());
+  CustomProbeOverrideDelegate delegate(probing_server.GetURL("a.test", "/"));
+  service->origin_prober()->SetProbeURLOverrideDelegateOverrideForTesting(
+      &delegate);
+
+  IsolatedPrerenderTabHelper* tab_helper =
+      IsolatedPrerenderTabHelper::FromWebContents(GetWebContents());
+
+  GURL eligible_link = GetOriginServerURLWithBadProbe("/title2.html");
+
+  TestTabHelperObserver tab_helper_observer(tab_helper);
+  tab_helper_observer.SetExpectedSuccessfulURLs({eligible_link});
+
+  base::RunLoop run_loop;
+  tab_helper_observer.SetOnPrefetchSuccessfulClosure(run_loop.QuitClosure());
+
+  GURL doc_url("https://www.google.com/search?q=test");
+  MakeNavigationPrediction(doc_url, {eligible_link});
+
+  // This run loop will quit when all the prefetch responses have been
+  // successfully done and processed.
+  run_loop.Run();
+
+  // Navigate to the prefetched page, this also triggers UKM recording.
+  size_t starting_origin_request_count = OriginServerRequestCount();
+  ASSERT_EQ(0U, probe_counter.count());
+  ui_test_utils::NavigateToURL(browser(), eligible_link);
+
+  EXPECT_EQ(1U, probe_counter.count());
+
+  // The request for the page should have hit the origin server, since the
+  // prefetched page couldn't be used.
+  EXPECT_EQ(starting_origin_request_count + 1, OriginServerRequestCount());
+
+  EXPECT_EQ(base::UTF8ToUTF16("Title Of Awesomeness"),
+            GetWebContents()->GetTitle());
+
+  ASSERT_TRUE(tab_helper->after_srp_metrics());
+  ASSERT_TRUE(tab_helper->after_srp_metrics()->prefetch_status_.has_value());
+  // 2 is the value of "prefetch used, probe failed". The test does not
+  // reference the enum directly to ensure that casting the enum to an int went
+  // cleanly, and to provide an extra review point if the value should ever
+  // accidentally change in the future, which it never should.
+  EXPECT_EQ(2, static_cast<int>(
+                   tab_helper->after_srp_metrics()->prefetch_status_.value()));
+
+  base::Optional<base::TimeDelta> probe_latency =
+      tab_helper->after_srp_metrics()->probe_latency_;
+  ASSERT_TRUE(probe_latency.has_value());
+  EXPECT_GT(probe_latency.value(), base::TimeDelta());
+
+  // Navigate again to trigger UKM recording.
+  ui_test_utils::NavigateToURL(browser(), GURL("about:blank"));
+  base::RunLoop().RunUntilIdle();
+
+  // 2 = |PrefetchStatus::kPrefetchNotUsedProbeFailed|.
+  EXPECT_EQ(base::Optional<int64_t>(2),
+            GetUKMMetric(eligible_link,
+                         ukm::builders::PrefetchProxy_AfterSRPClick::kEntryName,
+                         ukm::builders::PrefetchProxy_AfterSRPClick::
+                             kSRPClickPrefetchStatusName));
+  // The actual probe latency is hard to deterministically test for. Just make
+  // sure it is set within reasonable bounds.
+  base::Optional<int64_t> probe_latency_ms = GetUKMMetric(
+      eligible_link, ukm::builders::PrefetchProxy_AfterSRPClick::kEntryName,
+      ukm::builders::PrefetchProxy_AfterSRPClick::kProbeLatencyMsName);
+  EXPECT_NE(base::nullopt, probe_latency_ms);
+}
+
 // No probe should be done because the Canary Check is successful.
 IN_PROC_BROWSER_TEST_F(
     ProbingEnabled_CanaryOn_CanaryGood_IsolatedPrerenderBrowserTest,

diff --git a/chrome/browser/prerender/isolated/isolated_prerender_origin_prober.cc b/chrome/browser/prerender/isolated/isolated_prerender_origin_prober.cc
index ec5b8fd..f326f06 100644
--- a/chrome/browser/prerender/isolated/isolated_prerender_origin_prober.cc
+++ b/chrome/browser/prerender/isolated/isolated_prerender_origin_prober.cc

@@ -14,16 +14,47 @@
 #include "content/public/browser/browser_task_traits.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/storage_partition.h"
+#include "mojo/public/cpp/bindings/callback_helpers.h"
 #include "mojo/public/cpp/bindings/self_owned_receiver.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/isolation_info.h"
 #include "net/base/network_isolation_key.h"
 #include "services/network/public/mojom/host_resolver.mojom.h"
 #include "services/network/public/mojom/network_context.mojom.h"
+#include "services/network/public/mojom/tls_socket.mojom.h"
 #include "url/origin.h"
 
 namespace {
 
+net::NetworkTrafficAnnotationTag GetProbingTrafficAnnotation() {
+  return net::DefineNetworkTrafficAnnotation("isolated_prerender_probe", R"(
+        semantics {
+          sender: "Isolated Prerender Probe Loader"
+          description:
+            "Verifies the end to end connection between Chrome and the "
+            "origin site that the user is currently navigating to. This is "
+            "done during a navigation that was previously prerendered over a "
+            "proxy to check that the site is not blocked by middleboxes. "
+            "Such prerenders will be used to prefetch render-blocking "
+            "content before being navigated by the user without impacting "
+            "privacy."
+          trigger:
+            "Used for sites off of Google SRPs (Search Result Pages) only "
+            "for Lite mode users when the experimental feature flag is "
+            "enabled."
+          data: "None."
+          destination: WEBSITE
+        }
+        policy {
+          cookies_allowed: NO
+          setting:
+            "Users can control Lite mode on Android via the settings menu. "
+            "Lite mode is not available on iOS, and on desktop only for "
+            "developer testing."
+          policy_exception_justification: "Not implemented."
+      })");
+}
+
 class DNSProber : public network::mojom::ResolveHostClient {
  public:
   using OnDNSResultsCallback = base::OnceCallback<
@@ -57,6 +88,90 @@
   OnDNSResultsCallback callback_;
 };
 
+void TLSDropHandler(base::OnceClosure ui_only_callback) {
+  content::GetUIThreadTaskRunner({})->PostTask(FROM_HERE,
+                                               std::move(ui_only_callback));
+}
+
+class TLSProber {
+ public:
+  TLSProber(const GURL& url,
+            IsolatedPrerenderOriginProber::OnProbeResultCallback callback)
+      : url_(url), callback_(std::move(callback)) {}
+  ~TLSProber() { DCHECK(!callback_); }
+
+  network::mojom::NetworkContext::CreateTCPConnectedSocketCallback
+  GetOnTCPConnectedCallback() {
+    network::mojom::NetworkContext::CreateTCPConnectedSocketCallback
+        tcp_handler = base::BindOnce(&TLSProber::OnTCPConnected,
+                                     weak_factory_.GetWeakPtr());
+
+    return mojo::WrapCallbackWithDropHandler(std::move(tcp_handler),
+                                             GetDropHandler());
+  }
+
+  mojo::PendingReceiver<network::mojom::TCPConnectedSocket>
+  GetTCPSocketReceiver() {
+    return tcp_socket_.BindNewPipeAndPassReceiver();
+  }
+
+ private:
+  void OnTCPConnected(int result,
+                      const base::Optional<net::IPEndPoint>& local_addr,
+                      const base::Optional<net::IPEndPoint>& peer_addr,
+                      mojo::ScopedDataPipeConsumerHandle receive_stream,
+                      mojo::ScopedDataPipeProducerHandle send_stream) {
+    if (result != net::OK) {
+      HandleFailure();
+      return;
+    }
+
+    network::mojom::TCPConnectedSocket::UpgradeToTLSCallback tls_handler =
+        base::BindOnce(&TLSProber::OnUpgradeToTLS, weak_factory_.GetWeakPtr());
+
+    tcp_socket_->UpgradeToTLS(
+        net::HostPortPair::FromURL(url_), /*options=*/nullptr,
+        net::MutableNetworkTrafficAnnotationTag(GetProbingTrafficAnnotation()),
+        tls_socket_.BindNewPipeAndPassReceiver(),
+        /*observer=*/mojo::NullRemote(),
+        mojo::WrapCallbackWithDropHandler(std::move(tls_handler),
+                                          GetDropHandler()));
+  }
+
+  void OnUpgradeToTLS(int result,
+                      mojo::ScopedDataPipeConsumerHandle receive_stream,
+                      mojo::ScopedDataPipeProducerHandle send_stream,
+                      const base::Optional<net::SSLInfo>& ssl_info) {
+    std::move(callback_).Run(result == net::OK);
+    delete this;
+  }
+
+  base::OnceClosure GetDropHandler() {
+    // The drop handler is not guaranteed to be run on the original thread. Use
+    // the anon method above to fix that.
+    return base::BindOnce(
+        &TLSDropHandler,
+        base::BindOnce(&TLSProber::HandleFailure, weak_factory_.GetWeakPtr()));
+  }
+
+  void HandleFailure() {
+    std::move(callback_).Run(false);
+    delete this;
+  }
+
+  // The URL of the resource being probed. Only the host:port is used.
+  const GURL url_;
+
+  // The callback to run when the probe is complete.
+  IsolatedPrerenderOriginProber::OnProbeResultCallback callback_;
+
+  // Mojo sockets. We only test that both can be connected.
+  mojo::Remote<network::mojom::TCPConnectedSocket> tcp_socket_;
+  mojo::Remote<network::mojom::TLSClientSocket> tls_socket_;
+
+  base::WeakPtrFactory<TLSProber> weak_factory_{this};
+};
+
 void HTTPProbeHelper(
     std::unique_ptr<AvailabilityProber> prober,
     IsolatedPrerenderOriginProber::OnProbeResultCallback callback,
@@ -220,6 +335,9 @@
     case IsolatedPrerenderOriginProbeType::kHttpHead:
       HTTPProbe(probe_url, std::move(callback));
       return;
+    case IsolatedPrerenderOriginProbeType::kTls:
+      TLSProbe(probe_url, std::move(callback));
+      return;
   }
 }
 
@@ -228,6 +346,11 @@
   StartDNSResolution(url, std::move(callback), /*also_do_tls_connect=*/false);
 }
 
+void IsolatedPrerenderOriginProber::TLSProbe(const GURL& url,
+                                             OnProbeResultCallback callback) {
+  StartDNSResolution(url, std::move(callback), /*also_do_tls_connect=*/true);
+}
+
 void IsolatedPrerenderOriginProber::StartDNSResolution(
     const GURL& url,
     OnProbeResultCallback callback,
@@ -257,34 +380,6 @@
 
 void IsolatedPrerenderOriginProber::HTTPProbe(const GURL& url,
                                               OnProbeResultCallback callback) {
-  net::NetworkTrafficAnnotationTag traffic_annotation =
-      net::DefineNetworkTrafficAnnotation("isolated_prerender_probe", R"(
-          semantics {
-            sender: "Isolated Prerender Probe Loader"
-            description:
-              "Verifies the end to end connection between Chrome and the "
-              "origin site that the user is currently navigating to. This is "
-              "done during a navigation that was previously prerendered over a "
-              "proxy to check that the site is not blocked by middleboxes. "
-              "Such prerenders will be used to prefetch render-blocking "
-              "content before being navigated by the user without impacting "
-              "privacy."
-            trigger:
-              "Used for sites off of Google SRPs (Search Result Pages) only "
-              "for Lite mode users when the experimental feature flag is "
-              "enabled."
-            data: "None."
-            destination: WEBSITE
-          }
-          policy {
-            cookies_allowed: NO
-            setting:
-              "Users can control Lite mode on Android via the settings menu. "
-              "Lite mode is not available on iOS, and on desktop only for "
-              "developer testing."
-            policy_exception_justification: "Not implemented."
-        })");
-
   AvailabilityProber::TimeoutPolicy timeout_policy;
   timeout_policy.base_timeout = IsolatedPrerenderProbeTimeout();
   AvailabilityProber::RetryPolicy retry_policy;
@@ -298,7 +393,7 @@
           nullptr /* pref_service */,
           AvailabilityProber::ClientName::kIsolatedPrerenderOriginCheck, url,
           AvailabilityProber::HttpMethod::kHead, net::HttpRequestHeaders(),
-          retry_policy, timeout_policy, traffic_annotation,
+          retry_policy, timeout_policy, GetProbingTrafficAnnotation(),
           0 /* max_cache_entries */,
           base::TimeDelta::FromSeconds(0) /* revalidate_cache_after */);
   AvailabilityProber* prober_ptr = prober.get();
@@ -332,6 +427,28 @@
     return;
   }
 
-  // TODO(robertogden): Handle also_do_tls_connect.
-  NOTREACHED();
+  DoTLSProbeAfterDNSResolution(url, std::move(callback), *resolved_addresses);
+}
+
+void IsolatedPrerenderOriginProber::DoTLSProbeAfterDNSResolution(
+    const GURL& url,
+    OnProbeResultCallback callback,
+    const net::AddressList& addresses) {
+  DCHECK(!addresses.empty());
+
+  std::unique_ptr<TLSProber> prober =
+      std::make_unique<TLSProber>(url, std::move(callback));
+
+  content::BrowserContext::GetDefaultStoragePartition(profile_)
+      ->GetNetworkContext()
+      ->CreateTCPConnectedSocket(
+          /*local_addr=*/base::nullopt, addresses,
+          /*tcp_connected_socket_options=*/nullptr,
+          net::MutableNetworkTrafficAnnotationTag(
+              GetProbingTrafficAnnotation()),
+          prober->GetTCPSocketReceiver(),
+          /*observer=*/mojo::NullRemote(), prober->GetOnTCPConnectedCallback());
+
+  // |prober| manages its own lifetime, using the mojo pipes.
+  prober.release();
 }

diff --git a/chrome/browser/prerender/isolated/isolated_prerender_origin_prober.h b/chrome/browser/prerender/isolated/isolated_prerender_origin_prober.h
index 4999918..322231c1 100644
--- a/chrome/browser/prerender/isolated/isolated_prerender_origin_prober.h
+++ b/chrome/browser/prerender/isolated/isolated_prerender_origin_prober.h

@@ -48,6 +48,7 @@
  private:
   void DNSProbe(const GURL& url, OnProbeResultCallback callback);
   void HTTPProbe(const GURL& url, OnProbeResultCallback callback);
+  void TLSProbe(const GURL& url, OnProbeResultCallback callback);
 
   // Does a DNS resolution for a DNS or TLS probe, passing all the arguments to
   // |OnDNSResolved|.
@@ -55,6 +56,12 @@
                           OnProbeResultCallback callback,
                           bool also_do_tls_connect);
 
+  // Both DNS and TLS probes need to resolve DNS. This starts the TLS probe with
+  // the |addresses| from the DNS resolution.
+  void DoTLSProbeAfterDNSResolution(const GURL& url,
+                                    OnProbeResultCallback callback,
+                                    const net::AddressList& addresses);
+
   // If the DNS resolution was successful, this will either run |callback| for a
   // DNS probe, or start the TLS socket for a TLS probe. This is determined by
   // |also_do_tls_connect|. If the DNS resolution failed, |callback| is run with

diff --git a/chrome/browser/prerender/isolated/isolated_prerender_params.cc b/chrome/browser/prerender/isolated/isolated_prerender_params.cc
index df5ce69..67f31e51 100644
--- a/chrome/browser/prerender/isolated/isolated_prerender_params.cc
+++ b/chrome/browser/prerender/isolated/isolated_prerender_params.cc

@@ -131,6 +131,9 @@
     return IsolatedPrerenderOriginProbeType::kDns;
   if (param == "http_head")
     return IsolatedPrerenderOriginProbeType::kHttpHead;
+  if (param == "tls")
+    return IsolatedPrerenderOriginProbeType::kTls;
 
+  // Most restrictive by default.
   return IsolatedPrerenderOriginProbeType::kHttpHead;
 }

diff --git a/chrome/browser/prerender/isolated/isolated_prerender_params.h b/chrome/browser/prerender/isolated/isolated_prerender_params.h
index a91b848..39e8112 100644
--- a/chrome/browser/prerender/isolated/isolated_prerender_params.h
+++ b/chrome/browser/prerender/isolated/isolated_prerender_params.h

@@ -65,6 +65,7 @@
 enum class IsolatedPrerenderOriginProbeType {
   kDns,
   kHttpHead,
+  kTls,
 };
 IsolatedPrerenderOriginProbeType IsolatedPrerenderOriginProbeMechanism();
 

diff --git a/chrome/browser/prerender/prerender_nostate_prefetch_browsertest.cc b/chrome/browser/prerender/prerender_nostate_prefetch_browsertest.cc
index b55dc2c..f7ef0ea 100644
--- a/chrome/browser/prerender/prerender_nostate_prefetch_browsertest.cc
+++ b/chrome/browser/prerender/prerender_nostate_prefetch_browsertest.cc

@@ -1463,6 +1463,7 @@
       kPrefetchCanceledHistogram,
       base::Bind(
           [](const base::Closure& quit_closure, bool* called,
+             const char* histogram_name, uint64_t name_hash,
              base::HistogramBase::Sample sample) {
             *called = true;
             quit_closure.Run();

diff --git a/chrome/browser/profiles/profile_destroyer.cc b/chrome/browser/profiles/profile_destroyer.cc
index 6b81529..6b6120a 100644
--- a/chrome/browser/profiles/profile_destroyer.cc
+++ b/chrome/browser/profiles/profile_destroyer.cc

@@ -27,47 +27,71 @@
 
 }  // namespace
 
-ProfileDestroyer::DestroyerSet* ProfileDestroyer::pending_destroyers_ = NULL;
+ProfileDestroyer::DestroyerSet* ProfileDestroyer::pending_destroyers_ = nullptr;
 
 // static
 void ProfileDestroyer::DestroyProfileWhenAppropriate(Profile* const profile) {
-  TRACE_EVENT0("shutdown", "ProfileDestroyer::DestroyProfileWhenAppropriate");
+  TRACE_EVENT2("shutdown", "ProfileDestroyer::DestroyProfileWhenAppropriate",
+               "profile", profile, "is_off_the_record",
+               profile->IsOffTheRecord());
 
   DCHECK(profile);
   profile->MaybeSendDestroyedNotification();
 
-  HostSet profile_hosts = GetHostsForProfile(profile);
-  const bool profile_is_off_the_record = profile->IsOffTheRecord();
-  base::debug::Alias(&profile_is_off_the_record);
-  const bool profile_has_off_the_record =
-      !profile_is_off_the_record && profile->HasOffTheRecordProfile();
-  base::debug::Alias(&profile_has_off_the_record);
+  // TODO(https://crbug.com/1033903): If regular profile has OTRs and they have
+  // hosts, create a |ProfileDestroyer| instead.
+  if (!profile->IsOffTheRecord()) {
+    DestroyRegularProfileNow(profile);
+    return;
+  }
 
   // Off-the-record profiles have DestroyProfileWhenAppropriate() called before
   // their RenderProcessHosts are destroyed, to ensure private data is erased
   // promptly. In this case, defer deletion until all the hosts are gone.
-  if (profile_is_off_the_record) {
-    DCHECK(!profile_has_off_the_record);
-    if (profile_hosts.size()) {
-      // The instance will destroy itself once all (non-spare) render process
-      // hosts referring to it are properly terminated.
-      new ProfileDestroyer(profile, &profile_hosts);
-    } else {
-      profile->GetOriginalProfile()->DestroyOffTheRecordProfile(profile);
-    }
+  HostSet profile_hosts = GetHostsForProfile(profile);
+  if (profile_hosts.empty()) {
+    DestroyOffTheRecordProfileNow(profile);
     return;
   }
 
+  // The instance will destroy itself once all (non-spare) render process
+  // hosts referring to it are properly terminated.
+  new ProfileDestroyer(profile, &profile_hosts);
+}
+
+// static
+void ProfileDestroyer::DestroyOffTheRecordProfileNow(Profile* const profile) {
+  DCHECK(profile);
+  DCHECK(profile->IsOffTheRecord());
+  TRACE_EVENT1("shutdown", "ProfileDestroyer::DestroyOffTheRecordProfileNow",
+               "profile", profile);
+  if (ResetPendingDestroyers(profile)) {
+    // We want to signal this in debug builds so that we don't lose sight of
+    // these potential leaks, but we handle it in release so that we don't
+    // crash or corrupt profile data on disk.
+    NOTREACHED() << "A render process host wasn't destroyed early enough.";
+  }
+  DCHECK(profile->GetOriginalProfile());
+  profile->GetOriginalProfile()->DestroyOffTheRecordProfile(profile);
+}
+
+// static
+void ProfileDestroyer::DestroyRegularProfileNow(Profile* const profile) {
+  DCHECK(profile);
+  DCHECK(profile->IsRegularProfile());
+  TRACE_EVENT1("shutdown", "ProfileDestroyer::DestroyRegularProfileNow",
+               "profile", profile);
+
 #if DCHECK_IS_ON()
   // Save the raw pointers of profile and off-the-record profile for DCHECKing
   // on later.
+  HostSet profile_hosts = GetHostsForProfile(profile);
   void* profile_ptr = profile;
-  void* otr_profile_ptr =
-      profile_has_off_the_record ? profile->GetOffTheRecordProfile() : nullptr;
+  void* otr_profile_ptr = profile->HasOffTheRecordProfile()
+                              ? profile->GetOffTheRecordProfile()
+                              : nullptr;
 #endif  // DCHECK_IS_ON()
 
-  // TODO(https://crbug.com/1033903): If profile has OTRs and they have hosts,
-  // create a |ProfileDestroyer| instead.
   delete profile;
 
 #if DCHECK_IS_ON()
@@ -95,22 +119,6 @@
 #endif  // DCHECK_IS_ON()
 }
 
-// This can be called to cancel any pending destruction and destroy the profile
-// now, e.g., if the parent profile is being destroyed while the incognito one
-// still pending...
-void ProfileDestroyer::DestroyOffTheRecordProfileNow(Profile* const profile) {
-  DCHECK(profile);
-  DCHECK(profile->IsOffTheRecord());
-  if (ResetPendingDestroyers(profile)) {
-    // We want to signal this in debug builds so that we don't lose sight of
-    // these potential leaks, but we handle it in release so that we don't
-    // crash or corrupt profile data on disk.
-    NOTREACHED() << "A render process host wasn't destroyed early enough.";
-  }
-  DCHECK(profile->GetOriginalProfile());
-  profile->GetOriginalProfile()->DestroyOffTheRecordProfile(profile);
-}
-
 bool ProfileDestroyer::ResetPendingDestroyers(Profile* const profile) {
   DCHECK(profile);
   bool found = false;
@@ -127,6 +135,8 @@
 
 ProfileDestroyer::ProfileDestroyer(Profile* const profile, HostSet* hosts)
     : num_hosts_(0), profile_(profile) {
+  TRACE_EVENT2("shutdown", "ProfileDestroyer::ProfileDestroyer", "profile",
+               profile, "host_count", hosts->size());
   if (pending_destroyers_ == NULL)
     pending_destroyers_ = new DestroyerSet;
   pending_destroyers_->insert(this);
@@ -146,18 +156,19 @@
 }
 
 ProfileDestroyer::~ProfileDestroyer() {
+  TRACE_EVENT1("shutdown", "ProfileDestroyer::~ProfileDestroyer", "profile",
+               profile_);
+
   // Check again, in case other render hosts were added while we were
   // waiting for the previous ones to go away...
   if (profile_)
     DestroyProfileWhenAppropriate(profile_);
 
-#ifdef NDEBUG
   // Don't wait for pending registrations, if any, these hosts are buggy.
   // Note: this can happen, but if so, it's better to crash here than wait
   // for the host to dereference a deleted Profile. http://crbug.com/248625
   CHECK_EQ(0U, num_hosts_) << "Some render process hosts were not "
                            << "destroyed early enough!";
-#endif  // NDEBUG
   DCHECK(pending_destroyers_ != NULL);
   auto iter = pending_destroyers_->find(this);
   DCHECK(iter != pending_destroyers_->end());
@@ -170,6 +181,8 @@
 
 void ProfileDestroyer::RenderProcessHostDestroyed(
     content::RenderProcessHost* host) {
+  TRACE_EVENT2("shutdown", "ProfileDestroyer::RenderProcessHostDestroyed",
+               "profile", profile_, "render_process_host", host);
   DCHECK(num_hosts_ > 0);
   --num_hosts_;
   if (num_hosts_ == 0) {
@@ -224,6 +237,8 @@
     if (render_process_host->HostHasNotBeenUsed())
       continue;
 
+    TRACE_EVENT2("shutdown", "ProfileDestroyer::GetHostsForProfile", "profile",
+                 profile_ptr, "render_process_host", render_process_host);
     hosts.insert(render_process_host);
   }
   return hosts;

diff --git a/chrome/browser/profiles/profile_destroyer.h b/chrome/browser/profiles/profile_destroyer.h
index e7e5365..560742b 100644
--- a/chrome/browser/profiles/profile_destroyer.h
+++ b/chrome/browser/profiles/profile_destroyer.h

@@ -15,6 +15,7 @@
 #include "content/public/browser/render_process_host_observer.h"
 
 class Profile;
+class ProfileImpl;
 
 namespace content {
 class RenderProcessHost;
@@ -24,15 +25,14 @@
 // sure it gets done asynchronously after all render process hosts are gone.
 class ProfileDestroyer : public content::RenderProcessHostObserver {
  public:
+  // Destroys the given profile either instantly, or after a short delay waiting
+  // for dependent renderer process hosts to destroy.
+  // Ownership of the profile is passed to profile destroyer and the profile
+  // should not be used after this call.
   static void DestroyProfileWhenAppropriate(Profile* const profile);
-  static void DestroyOffTheRecordProfileNow(Profile* const profile);
-
-  // Reset pending destroyers whose target profile matches the given one
-  // to make it stop attempting to destroy it. Returns true if any object
-  // object was found to match and get reset.
-  static bool ResetPendingDestroyers(Profile* const profile);
 
  private:
+  friend class ProfileImpl;
   typedef std::set<content::RenderProcessHost*> HostSet;
   typedef std::set<ProfileDestroyer*> DestroyerSet;
 
@@ -52,6 +52,18 @@
   // pointer comparison is allowed, it will never be dereferenced as a Profile.
   static HostSet GetHostsForProfile(void* const profile_ptr);
 
+  // Destroys a regular profile immediately.
+  static void DestroyRegularProfileNow(Profile* const profile);
+
+  // Destroys an OffTheRecord profile immediately and removes it from all
+  // pending destroyers.
+  static void DestroyOffTheRecordProfileNow(Profile* const profile);
+
+  // Reset pending destroyers whose target profile matches the given one
+  // to make it stop attempting to destroy it. Returns true if any object
+  // object was found to match and get reset.
+  static bool ResetPendingDestroyers(Profile* const profile);
+
   // We need access to all pending destroyers so we can cancel them.
   static DestroyerSet* pending_destroyers_;
 

diff --git a/chrome/browser/renderer_context_menu/render_view_context_menu_unittest.cc b/chrome/browser/renderer_context_menu/render_view_context_menu_unittest.cc
index 17cd9cc..542ba69 100644
--- a/chrome/browser/renderer_context_menu/render_view_context_menu_unittest.cc
+++ b/chrome/browser/renderer_context_menu/render_view_context_menu_unittest.cc

@@ -562,7 +562,7 @@
   // Verify that the ContextMenu source frame is set as the navigation
   // initiator.
   auto main_frame_id = content::GlobalFrameRoutingId(
-      main_frame->GetProcess()->GetID(), main_frame->GetFrameTreeNodeId());
+      main_frame->GetProcess()->GetID(), main_frame->GetRoutingID());
   EXPECT_EQ(main_frame_id,
             delegate.last_navigation_params()->initiator_routing_id);
 

diff --git a/chrome/browser/resources/bluetooth_internals/adapter_broker.js b/chrome/browser/resources/bluetooth_internals/adapter_broker.js
index 1ca5ea6..d00d5ac 100644
--- a/chrome/browser/resources/bluetooth_internals/adapter_broker.js
+++ b/chrome/browser/resources/bluetooth_internals/adapter_broker.js

@@ -28,21 +28,21 @@
   /**
    * The proxy class of an adapter and router of adapter events.
    * Exposes an EventTarget interface that allows other object to subscribe to
-   * to specific AdapterClient events.
+   * to specific AdapterObserver events.
    * Provides remote access to Adapter functions. Converts parameters to Mojo
    * handles and back when necessary.
    *
-   * @implements {bluetooth.mojom.AdapterClientInterface}
+   * @implements {bluetooth.mojom.AdapterObserverInterface}
    */
   class AdapterBroker extends cr.EventTarget {
     /** @param {!AdapterRemote} adapter */
     constructor(adapter) {
       super();
-      this.adapterClientReceiver_ =
-          new bluetooth.mojom.AdapterClientReceiver(this);
+      this.adapterObserverReceiver_ =
+          new bluetooth.mojom.AdapterObserverReceiver(this);
       this.adapter_ = adapter;
-      this.adapter_.setClient(
-          this.adapterClientReceiver_.$.bindNewPipeAndPassRemote());
+      this.adapter_.addObserver(
+          this.adapterObserverReceiver_.$.bindNewPipeAndPassRemote());
     }
 
     presentChanged(present) {

diff --git a/chrome/browser/resources/chromeos/accessibility/BUILD.gn b/chrome/browser/resources/chromeos/accessibility/BUILD.gn
index 7baa912..1998283 100644
--- a/chrome/browser/resources/chromeos/accessibility/BUILD.gn
+++ b/chrome/browser/resources/chromeos/accessibility/BUILD.gn

@@ -145,21 +145,21 @@
   test_type = "unit"
   sources = [
     "braille_ime/braille_ime_unittest.js",
+    "common/rect_util_unittest.js",
     "select_to_speak/node_utils_unittest.js",
     "select_to_speak/paragraph_utils_unittest.js",
     "select_to_speak/rect_utils_unittest.js",
     "select_to_speak/select_to_speak_unittest.js",
     "select_to_speak/word_utils_unittest.js",
-    "switch_access/rect_helper_unittest.js",
   ]
   extra_js_files = [
     "braille_ime/braille_ime.js",
+    "common/rect_util.js",
     "select_to_speak/paragraph_utils.js",
     "select_to_speak/rect_utils.js",
     "select_to_speak/select_to_speak.js",
     "select_to_speak/test_support.js",
     "select_to_speak/word_utils.js",
     "select_to_speak/node_utils.js",
-    "switch_access/rect_helper.js",
   ]
 }

diff --git a/chrome/browser/resources/chromeos/accessibility/common/BUILD.gn b/chrome/browser/resources/chromeos/accessibility/common/BUILD.gn
index cedc32306..29088b65 100644
--- a/chrome/browser/resources/chromeos/accessibility/common/BUILD.gn
+++ b/chrome/browser/resources/chromeos/accessibility/common/BUILD.gn

@@ -30,6 +30,7 @@
     "closure_shim.js",
     "constants.js",
     "event_handler.js",
+    "rect_util.js",
     "repeated_event_handler.js",
     "repeated_tree_change_handler.js",
     "tree_walker.js",
@@ -85,6 +86,10 @@
   externs_list = [ "$externs_path/automation.js" ]
 }
 
+js_library("rect_util") {
+  externs_list = [ "$externs_path/accessibility_private.js" ]
+}
+
 js_library("repeated_event_handler") {
   externs_list = [ "$externs_path/automation.js" ]
 }

diff --git a/chrome/browser/resources/chromeos/accessibility/common/array_util_test.js b/chrome/browser/resources/chromeos/accessibility/common/array_util_test.js
index 261e5cd..f642c707 100644
--- a/chrome/browser/resources/chromeos/accessibility/common/array_util_test.js
+++ b/chrome/browser/resources/chromeos/accessibility/common/array_util_test.js

@@ -41,7 +41,7 @@
     assertTrue(
         ArrayUtil.contentsAreEqual(arrayWithObj, secondArrayWithObj),
         'Different array instances with references to the same object ' +
-            'instance should be equal with contentsareEqual.');
+            'instance should be equal with contentsAreEqual.');
     assertFalse(
         ArrayUtil.contentsAreEqual(arrayWithObj, arrayWithDifferentObj),
         'Arrays with different objects should not be equal (ArrayUtil.' +

diff --git a/chrome/browser/resources/chromeos/accessibility/common/event_handler.js b/chrome/browser/resources/chromeos/accessibility/common/event_handler.js
index a855501c..cc618c5 100644
--- a/chrome/browser/resources/chromeos/accessibility/common/event_handler.js
+++ b/chrome/browser/resources/chromeos/accessibility/common/event_handler.js

@@ -12,7 +12,7 @@
    *         !Array<!chrome.automation.AutomationNode>} nodes
    * @param {!chrome.automation.EventType |
    *     !Array<!chrome.automation.EventType>} types
-   * @param {!function(!chrome.automation.AutomationEvent)} callback
+   * @param {?function(!chrome.automation.AutomationEvent)} callback
    * @param {{capture: (boolean|undefined), exactMatch: (boolean|undefined),
    *     listenOnce: (boolean|undefined), predicate:
    *     ((function(chrome.automation.AutomationEvent): boolean)|undefined)}}
@@ -32,7 +32,7 @@
     /** @private {!Array<!chrome.automation.EventType>} */
     this.types_ = types instanceof Array ? types : [types];
 
-    /** @private {!function(!chrome.automation.AutomationEvent)} */
+    /** @private {?function(!chrome.automation.AutomationEvent)} */
     this.callback_ = callback;
 
     /** @private {boolean} */
@@ -81,6 +81,11 @@
     this.listening_ = false;
   }
 
+  /** @param {?function(!chrome.automation.AutomationEvent)} callback */
+  setCallback(callback) {
+    this.callback_ = callback;
+  }
+
   /**
    * Changes what nodes are being listened to. Removes listeners from existing
    *     nodes before adding listeners on new nodes.
@@ -138,6 +143,8 @@
       this.stop();
     }
 
-    this.callback_(event);
+    if (this.callback_) {
+      this.callback_(event);
+    }
   }
 }

diff --git a/chrome/browser/resources/chromeos/accessibility/common/rect_util.js b/chrome/browser/resources/chromeos/accessibility/common/rect_util.js
new file mode 100644
index 0000000..ed3e63db
--- /dev/null
+++ b/chrome/browser/resources/chromeos/accessibility/common/rect_util.js

@@ -0,0 +1,319 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+/**
+ * Equivalent to chrome.accessibilityPrivate.ScreenRect.
+ * @typedef {{top: number, left: number, width: number, height: number}}
+ */
+let ScreenRect;
+
+/** A collection of helper functions when dealing with rects. */
+const RectUtil = {
+  /** @type {!ScreenRect} */
+  ZERO_RECT: {top: 0, left: 0, width: 0, height: 0},
+
+  /**
+   * @param {!ScreenRect} rect1
+   * @param {!ScreenRect} rect2
+   * @return {boolean}
+   */
+  adjacent: (rect1, rect2) => {
+    const verticallyStacked = rect1.top === RectUtil.bottom(rect2) ||
+        RectUtil.bottom(rect1) === rect2.top;
+    const horizontallyStacked = rect1.left === RectUtil.right(rect2) ||
+        RectUtil.right(rect1) === rect2.left;
+
+    const verticallyOverlap =
+        (rect1.top >= rect2.top && rect1.top <= RectUtil.bottom(rect2)) ||
+        (rect2.top >= rect1.top && rect2.top <= RectUtil.bottom(rect1));
+    const horizontallyOverlap =
+        (rect1.left >= rect2.left && rect1.left <= RectUtil.right(rect2)) ||
+        (rect2.left >= rect1.left && rect2.left <= RectUtil.right(rect1));
+
+    return (verticallyStacked && horizontallyOverlap) ||
+        (horizontallyStacked && verticallyOverlap);
+  },
+
+  /**
+   * @param {ScreenRect|undefined} rect
+   * @return {number}
+   */
+  area: (rect) => rect ? rect.width * rect.height : 0,
+
+  /**
+   * Finds the bottom of a rect.
+   * @param {!ScreenRect} rect
+   * @return {number}
+   */
+  bottom: (rect) => rect.top + rect.height,
+
+  /**
+   * Returns the point at the center of the rectangle.
+   * @param {!ScreenRect} rect
+   * @return {!{x: number, y: number}} an object containing the x and y
+   *     coordinates of the center.
+   */
+  center: (rect) => {
+    const x = rect.left + Math.round(rect.width / 2);
+    const y = rect.top + Math.round(rect.height / 2);
+    return {x, y};
+  },
+
+  /**
+   * @param {ScreenRect} outer
+   * @param {ScreenRect} inner
+   * @return {boolean}
+   */
+  contains: (outer, inner) => {
+    if (!outer || !inner) {
+      return false;
+    }
+    return outer.left <= inner.left && outer.top <= inner.top &&
+        RectUtil.right(outer) >= RectUtil.right(inner) &&
+        RectUtil.bottom(outer) >= RectUtil.bottom(inner);
+  },
+
+  /**
+   * @param {!ScreenRect} rect
+   * @return {!ScreenRect}
+   */
+  deepCopy: (rect) => /** @type {!ScreenRect} */ (Object.assign({}, rect)),
+
+  /**
+   * Returns the largest rectangle contained within the outer rect that does not
+   * overlap with the subtrahend (what is being subtracted).
+   * @param {ScreenRect|undefined} outer
+   * @param {ScreenRect|undefined} subtrahend
+   * @return {ScreenRect|undefined}
+   */
+  difference: (outer, subtrahend) => {
+    if (!outer || !subtrahend) {
+      return outer;
+    }
+
+    if (outer.left >= RectUtil.right(subtrahend) ||
+        RectUtil.right(outer) <= subtrahend.left ||
+        outer.top >= RectUtil.bottom(subtrahend) ||
+        RectUtil.bottom(outer) <= subtrahend.top) {
+      // If the rectangles do not overlap, return the outer rect.
+      return outer;
+    }
+
+    if (RectUtil.contains(subtrahend, outer)) {
+      // If the subtrahend contains the outer rect, there is no region that does
+      // not overlap. Return the zero rect.
+      return RectUtil.ZERO_RECT;
+    }
+
+    let above, below, toTheLeft, toTheRight;
+
+    if (outer.top < subtrahend.top) {
+      above = {
+        top: outer.top,
+        left: outer.left,
+        width: outer.width,
+        height: (subtrahend.top - outer.top)
+      };
+    }
+
+    if (RectUtil.bottom(outer) > RectUtil.bottom(subtrahend)) {
+      below = {
+        top: RectUtil.bottom(subtrahend),
+        left: outer.left,
+        width: outer.width,
+        height: (RectUtil.bottom(outer) - RectUtil.bottom(subtrahend))
+      };
+    }
+
+    if (outer.left < subtrahend.left) {
+      toTheLeft = {
+        top: outer.top,
+        left: outer.left,
+        width: (subtrahend.left - outer.left),
+        height: outer.height
+      };
+    }
+
+    if (RectUtil.right(outer) > RectUtil.right(subtrahend)) {
+      toTheRight = {
+        top: outer.top,
+        left: RectUtil.right(subtrahend),
+        width: (RectUtil.right(outer) - RectUtil.right(subtrahend)),
+        height: outer.height
+      };
+    }
+
+    // Of the four rects calculated above, find the one with the greatest area.
+    const areaAbove = RectUtil.area(above);
+    const areaBelow = RectUtil.area(below);
+    const areaToTheLeft = RectUtil.area(toTheLeft);
+    const areaToTheRight = RectUtil.area(toTheRight);
+
+    if (areaAbove > areaBelow && areaAbove > areaToTheLeft &&
+        areaAbove > areaToTheRight) {
+      return above;
+    }
+
+    if (areaBelow > areaToTheLeft && areaBelow > areaToTheRight) {
+      return below;
+    }
+
+    return areaToTheLeft > areaToTheRight ? toTheLeft : toTheRight;
+  },
+
+  /**
+   * Returns true if the two rects are equal.
+   *
+   * @param {ScreenRect=} rect1
+   * @param {ScreenRect=} rect2
+   * @return {boolean}
+   */
+  equal: (rect1, rect2) => {
+    if (!rect1 && !rect2) {
+      return true;
+    }
+    if (!rect1 || !rect2) {
+      return false;
+    }
+    return rect1.left === rect2.left && rect1.top === rect2.top &&
+        rect1.width === rect2.width && rect1.height === rect2.height;
+  },
+
+  /**
+   * Increases the size of |outer| to entirely enclose |inner|, with |padding|
+   * buffer on each side.
+   * @param {number} padding
+   * @param {ScreenRect=} outer
+   * @param {ScreenRect=} inner
+   * @return {ScreenRect|undefined}
+   */
+  expandToFitWithPadding: (padding, outer, inner) => {
+    if (!outer || !inner) {
+      return outer;
+    }
+
+    const newOuter = RectUtil.deepCopy(outer);
+
+    if (newOuter.top > inner.top - padding) {
+      newOuter.top = inner.top - padding;
+      // The height should be the original bottom point less the new top point.
+      newOuter.height = RectUtil.bottom(outer) - newOuter.top;
+    }
+    if (newOuter.left > inner.left - padding) {
+      newOuter.left = inner.left - padding;
+      // The new width should be the original right point less the new left.
+      newOuter.width = RectUtil.right(outer) - newOuter.left;
+    }
+    if (RectUtil.bottom(newOuter) < RectUtil.bottom(inner) + padding) {
+      newOuter.height = RectUtil.bottom(inner) + padding - newOuter.top;
+    }
+    if (RectUtil.right(newOuter) < RectUtil.right(inner) + padding) {
+      newOuter.width = RectUtil.right(inner) + padding - newOuter.left;
+    }
+
+    return newOuter;
+  },
+
+  /**
+   * @param {ScreenRect=} rect1
+   * @param {ScreenRect=} rect2
+   * @return {ScreenRect}
+   */
+  intersection: (rect1, rect2) => {
+    if (!rect1 || !rect2) {
+      return RectUtil.ZERO_RECT;
+    }
+
+    const left = Math.max(rect1.left, rect2.left);
+    const top = Math.max(rect1.top, rect2.top);
+    const right = Math.min(RectUtil.right(rect1), RectUtil.right(rect2));
+    const bottom = Math.min(RectUtil.bottom(rect1), RectUtil.bottom(rect2));
+
+    if (right <= left || bottom <= top) {
+      return RectUtil.ZERO_RECT;
+    }
+
+    const width = right - left;
+    const height = bottom - top;
+
+    return {left, top, width, height};
+  },
+
+  /**
+   * Finds the right edge of a rect.
+   * @param {!ScreenRect} rect
+   * @return {number}
+   */
+  right: (rect) => rect.left + rect.width,
+
+  /*
+   * @param {ScreenRect=} rect1
+   * @param {ScreenRect=} rect2
+   * @return {boolean}
+   */
+  sameRow: (rect1, rect2) => {
+    if (!rect1 || !rect2) {
+      return false;
+    }
+    const bottom1 = RectUtil.bottom(rect1);
+    const middle2 = RectUtil.center(rect2).y;
+
+    return rect1.top < middle2 && bottom1 > middle2;
+  },
+
+  /**
+   * Returns a string representing the given rectangle.
+   * @param {ScreenRect|undefined} rect
+   * @return {string}
+   */
+  toString: (rect) => {
+    let str = '';
+    if (rect) {
+      str = rect.left + ',' + rect.top + ' ';
+      str += rect.width + 'x' + rect.height;
+    }
+    return str;
+  },
+
+  /**
+   * Returns the union of the specified rectangles.
+   * @param {!ScreenRect} rect1
+   * @param {!ScreenRect} rect2
+   * @return {!ScreenRect}
+   */
+  union: (rect1, rect2) => {
+    const top = rect1.top < rect2.top ? rect1.top : rect2.top;
+    const left = rect1.left < rect2.left ? rect1.left : rect2.left;
+
+    const r1Bottom = RectUtil.bottom(rect1);
+    const r2Bottom = RectUtil.bottom(rect2);
+    const bottom = r1Bottom > r2Bottom ? r1Bottom : r2Bottom;
+
+    const r1Right = RectUtil.right(rect1);
+    const r2Right = RectUtil.right(rect2);
+    const right = r1Right > r2Right ? r1Right : r2Right;
+
+    const height = bottom - top;
+    const width = right - left;
+
+    return {top, left, width, height};
+  },
+
+  /**
+   * Returns the union of all the rectangles specified.
+   * @param {!Array<!ScreenRect>} rects
+   * @return {!ScreenRect}
+   */
+  unionAll: (rects) => {
+    if (rects.length < 1) {
+      return RectUtil.ZERO_RECT;
+    }
+
+    let result = rects[0];
+    for (let i = 1; i < rects.length; i++) {
+      result = RectUtil.union(result, rects[i]);
+    }
+    return result;
+  }
+};

diff --git a/chrome/browser/resources/chromeos/accessibility/switch_access/rect_helper_unittest.js b/chrome/browser/resources/chromeos/accessibility/common/rect_util_unittest.js
similarity index 62%
rename from chrome/browser/resources/chromeos/accessibility/switch_access/rect_helper_unittest.js
rename to chrome/browser/resources/chromeos/accessibility/common/rect_util_unittest.js
index 80657ab..1bbfa19 100644
--- a/chrome/browser/resources/chromeos/accessibility/switch_access/rect_helper_unittest.js
+++ b/chrome/browser/resources/chromeos/accessibility/common/rect_util_unittest.js

@@ -2,13 +2,13 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-/** Test fixture for rect_helper.js. */
-SwitchAccessRectHelperUnitTest = class extends testing.Test {};
+/** Test fixture for rect_util.js. */
+RectUtilUnitTest = class extends testing.Test {};
 
 /** @override */
-SwitchAccessRectHelperUnitTest.prototype.extraLibraries = ['rect_helper.js'];
+RectUtilUnitTest.prototype.extraLibraries = ['rect_util.js'];
 
-TEST_F('SwitchAccessRectHelperUnitTest', 'Adjacent', function() {
+TEST_F('RectUtilUnitTest', 'Adjacent', function() {
   const baseRect = {left: 10, top: 10, width: 10, height: 10};
   const adjacentRects = [
     {left: 0, top: 0, width: 10, height: 10},
@@ -50,28 +50,28 @@
 
   for (const rect of adjacentRects) {
     assertTrue(
-        RectHelper.areAdjacent(baseRect, rect),
-        RectHelper.toString(baseRect) + ' should be adjacent to ' +
-            RectHelper.toString(rect));
+        RectUtil.adjacent(baseRect, rect),
+        RectUtil.toString(baseRect) + ' should be adjacent to ' +
+            RectUtil.toString(rect));
     assertTrue(
-        RectHelper.areAdjacent(rect, baseRect),
-        RectHelper.toString(rect) + ' should be adjacent to ' +
-            RectHelper.toString(baseRect));
+        RectUtil.adjacent(rect, baseRect),
+        RectUtil.toString(rect) + ' should be adjacent to ' +
+            RectUtil.toString(baseRect));
   }
 
   for (const rect of nonAdjacentRects) {
     assertFalse(
-        RectHelper.areAdjacent(baseRect, rect),
-        RectHelper.toString(baseRect) + ' should not be adjacent to ' +
-            RectHelper.toString(rect));
+        RectUtil.adjacent(baseRect, rect),
+        RectUtil.toString(baseRect) + ' should not be adjacent to ' +
+            RectUtil.toString(rect));
     assertFalse(
-        RectHelper.areAdjacent(rect, baseRect),
-        RectHelper.toString(rect) + ' should not be adjacent to ' +
-            RectHelper.toString(baseRect));
+        RectUtil.adjacent(rect, baseRect),
+        RectUtil.toString(rect) + ' should not be adjacent to ' +
+            RectUtil.toString(baseRect));
   }
 });
 
-TEST_F('SwitchAccessRectHelperUnitTest', 'Equals', function() {
+TEST_F('RectUtilUnitTest', 'Equals', function() {
   const rect1 = {left: 0, top: 0, width: 10, height: 10};
   const rect2 = {left: 0, top: 0, width: 10, height: 10};
   const rect3 = {left: 1, top: 0, width: 10, height: 10};
@@ -79,43 +79,37 @@
   const rect5 = {left: 0, top: 0, width: 11, height: 10};
   const rect6 = {left: 0, top: 0, width: 10, height: 11};
 
-  assertTrue(RectHelper.areEqual(rect1, rect1), 'areEqual should be reflexive');
-  assertTrue(
-      RectHelper.areEqual(rect1, rect2), 'Rect1 and Rect2 should be equal');
-  assertTrue(
-      RectHelper.areEqual(rect2, rect1), 'areEqual should be symmetric (1)');
+  assertTrue(RectUtil.equal(rect1, rect1), 'equal should be reflexive');
+  assertTrue(RectUtil.equal(rect1, rect2), 'Rect1 and Rect2 should be equal');
+  assertTrue(RectUtil.equal(rect2, rect1), 'equal should be symmetric');
   assertFalse(
-      RectHelper.areEqual(rect1, rect3), 'rect1 and rect3 should not be equal');
+      RectUtil.equal(rect1, rect3), 'rect1 and rect3 should not be equal');
+  assertFalse(RectUtil.equal(rect3, rect1), 'equal should be symmetric');
   assertFalse(
-      RectHelper.areEqual(rect3, rect1), 'areEqual should be symmetric (2)');
+      RectUtil.equal(rect1, rect4), 'rect1 and rect4 should not be equal');
+  assertFalse(RectUtil.equal(rect4, rect1), 'equal should be symmetric');
   assertFalse(
-      RectHelper.areEqual(rect1, rect4), 'rect1 and rect4 should not be equal');
+      RectUtil.equal(rect1, rect5), 'rect1 and rect5 should not be equal');
+  assertFalse(RectUtil.equal(rect5, rect1), 'equal should be symmetric');
   assertFalse(
-      RectHelper.areEqual(rect4, rect1), 'areEqual should be symmetric (3)');
-  assertFalse(
-      RectHelper.areEqual(rect1, rect5), 'rect1 and rect5 should not be equal');
-  assertFalse(
-      RectHelper.areEqual(rect5, rect1), 'areEqual should be symmetric (4)');
-  assertFalse(
-      RectHelper.areEqual(rect1, rect6), 'rect1 and rect6 should not be equal');
-  assertFalse(
-      RectHelper.areEqual(rect6, rect1), 'areEqual should be symmetric (5)');
+      RectUtil.equal(rect1, rect6), 'rect1 and rect6 should not be equal');
+  assertFalse(RectUtil.equal(rect6, rect1), 'equal should be symmetric');
 });
 
-TEST_F('SwitchAccessRectHelperUnitTest', 'Center', function() {
+TEST_F('RectUtilUnitTest', 'Center', function() {
   const rect1 = {left: 0, top: 0, width: 10, height: 10};
   const rect2 = {left: 10, top: 20, width: 10, height: 40};
 
-  const center1 = RectHelper.center(rect1);
+  const center1 = RectUtil.center(rect1);
   assertEquals(5, center1.x, 'Center1 x should be 5');
   assertEquals(5, center1.y, 'Center1 y should be 5');
 
-  const center2 = RectHelper.center(rect2);
+  const center2 = RectUtil.center(rect2);
   assertEquals(15, center2.x, 'Center2 x should be 15');
   assertEquals(40, center2.y, 'Center2 y should be 40');
 });
 
-TEST_F('SwitchAccessRectHelperUnitTest', 'Union', function() {
+TEST_F('RectUtilUnitTest', 'Union', function() {
   const rect1 = {left: 0, top: 0, width: 10, height: 10};
   const rect2 = {left: 4, top: 4, width: 2, height: 2};
   const rect3 = {left: 10, top: 20, width: 10, height: 40};
@@ -123,74 +117,74 @@
   const rect5 = {left: 5, top: 5, width: 10, height: 10};
 
   // When one rect entirely contains the other, that rect is returned.
-  const unionRect1Rect2 = RectHelper.union(rect1, rect2);
+  const unionRect1Rect2 = RectUtil.union(rect1, rect2);
   assertTrue(
-      RectHelper.areEqual(rect1, unionRect1Rect2),
+      RectUtil.equal(rect1, unionRect1Rect2),
       'Union of rect1 and rect2 should be rect1');
 
-  const unionRect1Rect3 = RectHelper.union(rect1, rect3);
+  const unionRect1Rect3 = RectUtil.union(rect1, rect3);
   let expected = {left: 0, top: 0, width: 20, height: 60};
   assertTrue(
-      RectHelper.areEqual(expected, unionRect1Rect3),
+      RectUtil.equal(expected, unionRect1Rect3),
       'Union of rect1 and rect3 does not match expected value');
 
-  const unionRect1Rect4 = RectHelper.union(rect1, rect4);
+  const unionRect1Rect4 = RectUtil.union(rect1, rect4);
   expected = {left: 0, top: 0, width: 10, height: 20};
   assertTrue(
-      RectHelper.areEqual(expected, unionRect1Rect4),
+      RectUtil.equal(expected, unionRect1Rect4),
       'Union of rect1 and rect4 does not match expected value');
 
-  const unionRect1Rect5 = RectHelper.union(rect1, rect5);
+  const unionRect1Rect5 = RectUtil.union(rect1, rect5);
   expected = {left: 0, top: 0, width: 15, height: 15};
   assertTrue(
-      RectHelper.areEqual(expected, unionRect1Rect5),
+      RectUtil.equal(expected, unionRect1Rect5),
       'Union of rect1 and rect5 does not match expected value');
 });
 
-TEST_F('SwitchAccessRectHelperUnitTest', 'UnionAll', function() {
+TEST_F('RectUtilUnitTest', 'UnionAll', function() {
   const rect1 = {left: 0, top: 0, width: 10, height: 10};
   const rect2 = {left: 0, top: 10, width: 10, height: 10};
   const rect3 = {left: 10, top: 0, width: 10, height: 10};
   const rect4 = {left: 10, top: 10, width: 10, height: 10};
   const rect5 = {left: 0, top: 0, width: 100, height: 10};
 
-  const union1 = RectHelper.unionAll([rect1, rect2, rect3, rect4]);
+  const union1 = RectUtil.unionAll([rect1, rect2, rect3, rect4]);
   let expected = {left: 0, top: 0, width: 20, height: 20};
   assertTrue(
-      RectHelper.areEqual(expected, union1),
+      RectUtil.equal(expected, union1),
       'Union of rects 1-4 does not match expected value');
 
-  const union2 = RectHelper.unionAll([rect1, rect2, rect3, rect4, rect5]);
+  const union2 = RectUtil.unionAll([rect1, rect2, rect3, rect4, rect5]);
   expected = {left: 0, top: 0, width: 100, height: 20};
   assertTrue(
-      RectHelper.areEqual(expected, union2),
+      RectUtil.equal(expected, union2),
       'Union of rects 1-5 does not match expected value');
 });
 
-TEST_F('SwitchAccessRectHelperUnitTest', 'ExpandToFitWithPadding', function() {
+TEST_F('RectUtilUnitTest', 'ExpandToFitWithPadding', function() {
   const padding = 5;
   let inner = {left: 100, top: 100, width: 100, height: 100};
   let outer = {left: 120, top: 120, width: 20, height: 20};
   let expected = {left: 95, top: 95, width: 110, height: 110};
   assertTrue(
-      RectHelper.areEqual(
-          expected, RectHelper.expandToFitWithPadding(padding, outer, inner)),
+      RectUtil.equal(
+          expected, RectUtil.expandToFitWithPadding(padding, outer, inner)),
       'When outer is contained in inner, expandToFitWithPadding does not ' +
           'match expected value');
 
   inner = {left: 100, top: 100, width: 100, height: 100};
   outer = {left: 50, top: 50, width: 200, height: 200};
   assertTrue(
-      RectHelper.areEqual(
-          outer, RectHelper.expandToFitWithPadding(padding, outer, inner)),
+      RectUtil.equal(
+          outer, RectUtil.expandToFitWithPadding(padding, outer, inner)),
       'When outer contains inner, expandToFitWithPadding should equal outer');
 
   inner = {left: 100, top: 100, width: 100, height: 100};
   outer = {left: 10, top: 10, width: 10, height: 10};
   expected = {left: 10, top: 10, width: 195, height: 195};
   assertTrue(
-      RectHelper.areEqual(
-          expected, RectHelper.expandToFitWithPadding(padding, outer, inner)),
+      RectUtil.equal(
+          expected, RectUtil.expandToFitWithPadding(padding, outer, inner)),
       'When there is no overlap, expandToFitWithPadding does not match ' +
           'expected value');
 
@@ -198,8 +192,8 @@
   outer = {left: 120, top: 50, width: 200, height: 200};
   expected = {left: 95, top: 50, width: 225, height: 200};
   assertTrue(
-      RectHelper.areEqual(
-          expected, RectHelper.expandToFitWithPadding(padding, outer, inner)),
+      RectUtil.equal(
+          expected, RectUtil.expandToFitWithPadding(padding, outer, inner)),
       'When there is some overlap, expandToFitWithPadding does not match ' +
           'expected value');
 
@@ -207,168 +201,165 @@
   outer = {left: 97, top: 95, width: 108, height: 110};
   expected = {left: 95, top: 95, width: 110, height: 110};
   assertTrue(
-      RectHelper.areEqual(
-          expected, RectHelper.expandToFitWithPadding(padding, outer, inner)),
+      RectUtil.equal(
+          expected, RectUtil.expandToFitWithPadding(padding, outer, inner)),
       'When outer contains inner but without sufficient padding, ' +
           'expandToFitWithPadding does not match expected value');
 });
 
-TEST_F('SwitchAccessRectHelperUnitTest', 'Contains', function() {
+TEST_F('RectUtilUnitTest', 'Contains', function() {
   const outer = {left: 10, top: 10, width: 10, height: 10};
-  assertTrue(RectHelper.contains(outer, outer), 'Rect should contain itself');
+  assertTrue(RectUtil.contains(outer, outer), 'Rect should contain itself');
 
   let inner = {left: 10, top: 12, width: 10, height: 5};
   assertTrue(
-      RectHelper.contains(outer, inner),
+      RectUtil.contains(outer, inner),
       'Rect should contain rect with same left/right bounds');
   inner = {left: 12, top: 10, width: 5, height: 10};
   assertTrue(
-      RectHelper.contains(outer, inner),
+      RectUtil.contains(outer, inner),
       'Rect should contain rect with same top/bottom bounds');
   inner = {left: 12, top: 12, width: 5, height: 5};
   assertTrue(
-      RectHelper.contains(outer, inner),
+      RectUtil.contains(outer, inner),
       'Rect should contain rect that is entirely within its bounds');
 
   inner = {left: 5, top: 12, width: 10, height: 5};
   assertFalse(
-      RectHelper.contains(outer, inner),
+      RectUtil.contains(outer, inner),
       'Rect should not contain rect that extends past the left edge');
   inner = {left: 12, top: 8, width: 5, height: 10};
   assertFalse(
-      RectHelper.contains(outer, inner),
+      RectUtil.contains(outer, inner),
       'Rect should not contain rect that extends past the top edge');
   inner = {left: 15, top: 5, width: 10, height: 20};
   assertFalse(
-      RectHelper.contains(outer, inner),
+      RectUtil.contains(outer, inner),
       'Rect should not contain rect that extends past right edge and has ' +
           'larger height');
   inner = {left: 5, top: 15, width: 10, height: 10};
   assertFalse(
-      RectHelper.contains(outer, inner),
+      RectUtil.contains(outer, inner),
       'Rect should not contain rect that extends below and left of it');
   inner = {left: 2, top: 12, width: 5, height: 5};
   assertFalse(
-      RectHelper.contains(outer, inner),
+      RectUtil.contains(outer, inner),
       'Rect should not contain rect directly to its left');
   inner = {left: 12, top: 22, width: 5, height: 5};
   assertFalse(
-      RectHelper.contains(outer, inner),
+      RectUtil.contains(outer, inner),
       'Rect should not contain rect directly below it');
   inner = {left: 22, top: 2, width: 5, height: 5};
   assertFalse(
-      RectHelper.contains(outer, inner),
+      RectUtil.contains(outer, inner),
       'Rect should not contain rect above the the top-right corner');
   inner = {left: 12, top: 2, width: 5, height: 20};
   assertFalse(
-      RectHelper.contains(outer, inner),
+      RectUtil.contains(outer, inner),
       'Rect should not contain rect that has a greater height');
   inner = {left: 2, top: 12, width: 20, height: 5};
   assertFalse(
-      RectHelper.contains(outer, inner),
+      RectUtil.contains(outer, inner),
       'Rect should not contain rect that has a larger width');
 });
 
 
-TEST_F('SwitchAccessRectHelperUnitTest', 'Difference', function() {
+TEST_F('RectUtilUnitTest', 'Difference', function() {
   const outer = {left: 10, top: 10, width: 10, height: 10};
   assertTrue(
-      RectHelper.areEqual(
-          RectHelper.ZERO_RECT, RectHelper.difference(outer, outer)),
+      RectUtil.equal(RectUtil.ZERO_RECT, RectUtil.difference(outer, outer)),
       'Difference of rect with itself should the zero rect');
 
   let subtrahend = {left: 2, top: 2, width: 5, height: 5};
   assertTrue(
-      RectHelper.areEqual(outer, RectHelper.difference(outer, subtrahend)),
+      RectUtil.equal(outer, RectUtil.difference(outer, subtrahend)),
       'Difference of non-overlapping rects should be the outer rect');
 
   subtrahend = {left: 5, top: 5, width: 20, height: 20};
   assertTrue(
-      RectHelper.areEqual(
-          RectHelper.ZERO_RECT, RectHelper.difference(outer, subtrahend)),
+      RectUtil.equal(
+          RectUtil.ZERO_RECT, RectUtil.difference(outer, subtrahend)),
       'Difference where subtrahend contains outer should be the zero rect');
 
   subtrahend = {left: 12, top: 15, width: 6, height: 3};
   let expected = {left: 10, top: 10, width: 10, height: 5};
   assertTrue(
-      RectHelper.areEqual(expected, RectHelper.difference(outer, subtrahend)),
+      RectUtil.equal(expected, RectUtil.difference(outer, subtrahend)),
       'Difference above should be largest');
 
   subtrahend = {left: 15, top: 8, width: 3, height: 10};
   expected = {left: 10, top: 10, width: 5, height: 10};
   assertTrue(
-      RectHelper.areEqual(expected, RectHelper.difference(outer, subtrahend)),
+      RectUtil.equal(expected, RectUtil.difference(outer, subtrahend)),
       'Difference to the left should be the largest');
 
   subtrahend = {left: 5, top: 5, width: 13, height: 10};
   expected = {left: 10, top: 15, width: 10, height: 5};
   assertTrue(
-      RectHelper.areEqual(expected, RectHelper.difference(outer, subtrahend)),
+      RectUtil.equal(expected, RectUtil.difference(outer, subtrahend)),
       'Difference below should be the largest');
 
   subtrahend = {left: 8, top: 8, width: 10, height: 15};
   expected = {left: 18, top: 10, width: 2, height: 10};
   assertTrue(
-      RectHelper.areEqual(expected, RectHelper.difference(outer, subtrahend)),
+      RectUtil.equal(expected, RectUtil.difference(outer, subtrahend)),
       'Difference to the right should be the largest');
 });
 
-TEST_F('SwitchAccessRectHelperUnitTest', 'Intersection', function() {
+TEST_F('RectUtilUnitTest', 'Intersection', function() {
   const rect1 = {left: 10, top: 10, width: 10, height: 10};
   assertTrue(
-      RectHelper.areEqual(rect1, RectHelper.intersection(rect1, rect1)),
+      RectUtil.equal(rect1, RectUtil.intersection(rect1, rect1)),
       'Intersection of a rectangle with itself should be itself');
 
   let rect2 = {left: 12, top: 12, width: 5, height: 5};
   assertTrue(
-      RectHelper.areEqual(rect2, RectHelper.intersection(rect1, rect2)),
+      RectUtil.equal(rect2, RectUtil.intersection(rect1, rect2)),
       'When one rect contains another, intersection should be the inner rect');
   assertTrue(
-      RectHelper.areEqual(rect2, RectHelper.intersection(rect2, rect1)),
+      RectUtil.equal(rect2, RectUtil.intersection(rect2, rect1)),
       'Intersection should be symmetric');
 
   rect2 = {left: 5, top: 5, width: 20, height: 20};
   assertTrue(
-      RectHelper.areEqual(rect1, RectHelper.intersection(rect1, rect2)),
+      RectUtil.equal(rect1, RectUtil.intersection(rect1, rect2)),
       'When one rect contains another, intersection should be the inner rect');
   assertTrue(
-      RectHelper.areEqual(rect1, RectHelper.intersection(rect2, rect1)),
+      RectUtil.equal(rect1, RectUtil.intersection(rect2, rect1)),
       'Intersection should be symmetric');
 
   rect2 = {left: 30, top: 10, width: 10, height: 10};
   assertTrue(
-      RectHelper.areEqual(
-          RectHelper.ZERO_RECT, RectHelper.intersection(rect1, rect2)),
+      RectUtil.equal(RectUtil.ZERO_RECT, RectUtil.intersection(rect1, rect2)),
       'Intersection of non-overlapping rects should be zero rect');
   assertTrue(
-      RectHelper.areEqual(
-          RectHelper.ZERO_RECT, RectHelper.intersection(rect2, rect1)),
+      RectUtil.equal(RectUtil.ZERO_RECT, RectUtil.intersection(rect2, rect1)),
       'Intersection should be symmetric');
 
   rect2 = {left: 15, top: 10, width: 10, height: 10};
   let expected = {left: 15, top: 10, width: 5, height: 10};
   assertTrue(
-      RectHelper.areEqual(expected, RectHelper.intersection(rect1, rect2)),
+      RectUtil.equal(expected, RectUtil.intersection(rect1, rect2)),
       'Side-by-side overlap is not computed correctly');
   assertTrue(
-      RectHelper.areEqual(expected, RectHelper.intersection(rect2, rect1)),
+      RectUtil.equal(expected, RectUtil.intersection(rect2, rect1)),
       'Intersection should be symmetric');
 
   rect2 = {left: 15, top: 5, width: 10, height: 10};
   expected = {left: 15, top: 10, width: 5, height: 5};
   assertTrue(
-      RectHelper.areEqual(expected, RectHelper.intersection(rect1, rect2)),
+      RectUtil.equal(expected, RectUtil.intersection(rect1, rect2)),
       'Top corner overlap is not computed correctly');
   assertTrue(
-      RectHelper.areEqual(expected, RectHelper.intersection(rect2, rect1)),
+      RectUtil.equal(expected, RectUtil.intersection(rect2, rect1)),
       'Intersection should be symmetric');
 
   rect2 = {left: 5, top: 15, width: 20, height: 10};
   expected = {left: 10, top: 15, width: 10, height: 5};
   assertTrue(
-      RectHelper.areEqual(expected, RectHelper.intersection(rect1, rect2)),
+      RectUtil.equal(expected, RectUtil.intersection(rect1, rect2)),
       'Bottom overlap is not computed correctly');
   assertTrue(
-      RectHelper.areEqual(expected, RectHelper.intersection(rect2, rect1)),
+      RectUtil.equal(expected, RectUtil.intersection(rect2, rect1)),
       'Intersection should be symmetric');
 });

diff --git a/chrome/browser/resources/chromeos/accessibility/switch_access/BUILD.gn b/chrome/browser/resources/chromeos/accessibility/switch_access/BUILD.gn
index eaa633a..586cbd5 100644
--- a/chrome/browser/resources/chromeos/accessibility/switch_access/BUILD.gn
+++ b/chrome/browser/resources/chromeos/accessibility/switch_access/BUILD.gn

@@ -74,7 +74,6 @@
     "nodes/tab_node.js",
     "nodes/window_node.js",
     "preferences.js",
-    "rect_helper.js",
     "switch_access.js",
     "switch_access_constants.js",
     "switch_access_predicate.js",
@@ -150,7 +149,6 @@
     ":navigation_manager",
     ":node_wrapper",
     ":preferences",
-    ":rect_helper",
     ":slider_node",
     ":switch_access",
     ":switch_access_constants",
@@ -162,6 +160,7 @@
     "../common:automation_predicate",
     "../common:closure_shim",
     "../common:constants",
+    "../common:rect_util",
     "../common:repeated_event_handler",
     "../common:repeated_tree_change_handler",
     "../common:tree_walker",
@@ -180,9 +179,9 @@
 js_library("back_button_node") {
   sources = [ "nodes/back_button_node.js" ]
   deps = [
-    ":rect_helper",
     ":switch_access_constants",
     ":switch_access_node",
+    "../common:rect_util",
   ]
   externs_list = [
     "$externs_path/accessibility_private.js",
@@ -250,9 +249,9 @@
   deps = [
     ":back_button_node",
     ":node_wrapper",
-    ":rect_helper",
     ":switch_access_constants",
     ":switch_access_node",
+    "../common:rect_util",
   ]
   externs_list = [
     "$externs_path/accessibility_private.js",
@@ -277,11 +276,11 @@
     ":event_helper",
     ":group_node",
     ":node_wrapper",
-    ":rect_helper",
     ":switch_access_constants",
     ":switch_access_node",
     ":switch_access_predicate",
     "../common:constants",
+    "../common:rect_util",
     "../common:tree_walker",
   ]
   externs_list = [
@@ -365,10 +364,6 @@
   externs_list = [ "$externs_path/settings_private.js" ]
 }
 
-js_library("rect_helper") {
-  externs_list = [ "$externs_path/accessibility_private.js" ]
-}
-
 js_library("slider_node") {
   sources = [ "nodes/slider_node.js" ]
   deps = [
@@ -424,9 +419,9 @@
   sources = [ "nodes/tab_node.js" ]
   deps = [
     ":node_wrapper",
-    ":rect_helper",
     ":switch_access_constants",
     ":switch_access_node",
+    "../common:rect_util",
   ]
   externs_list = [ "$externs_path/automation.js" ]
 }

diff --git a/chrome/browser/resources/chromeos/accessibility/switch_access/focus_ring_manager.js b/chrome/browser/resources/chromeos/accessibility/switch_access/focus_ring_manager.js
index 9d3ab428..c106618 100644
--- a/chrome/browser/resources/chromeos/accessibility/switch_access/focus_ring_manager.js
+++ b/chrome/browser/resources/chromeos/accessibility/switch_access/focus_ring_manager.js

@@ -97,7 +97,7 @@
       if (childRect) {
         // If the current element is not the back button, the focus rect should
         // expand to contain the child rect.
-        focusRect = RectHelper.expandToFitWithPadding(
+        focusRect = RectUtil.expandToFitWithPadding(
             SAConstants.Focus.GROUP_BUFFER, focusRect, childRect);
         manager.rings_.get(SAConstants.Focus.ID.NEXT).rects = [childRect];
       }

diff --git a/chrome/browser/resources/chromeos/accessibility/switch_access/navigation_manager.js b/chrome/browser/resources/chromeos/accessibility/switch_access/navigation_manager.js
index a75bce6..0a02578 100644
--- a/chrome/browser/resources/chromeos/accessibility/switch_access/navigation_manager.js
+++ b/chrome/browser/resources/chromeos/accessibility/switch_access/navigation_manager.js

@@ -203,11 +203,11 @@
     if (!location) {
       // Closure compiler doesn't realize we already checked isValidAndVisible
       // before calling tryMoving, so we need to explicitly check location here
-      // so that RectHelper.center does not cause a closure error.
+      // so that RectUtil.center does not cause a closure error.
       NavigationManager.moveToValidNode();
       return;
     }
-    const center = RectHelper.center(location);
+    const center = RectUtil.center(location);
     // Check if the top center is visible as a proxy for occlusion. It's
     // possible that other parts of the window are occluded, but in Chrome we
     // can't drag windows off the top of the screen.

diff --git a/chrome/browser/resources/chromeos/accessibility/switch_access/nodes/group_node.js b/chrome/browser/resources/chromeos/accessibility/switch_access/nodes/group_node.js
index 6a3b613..a9126ae 100644
--- a/chrome/browser/resources/chromeos/accessibility/switch_access/nodes/group_node.js
+++ b/chrome/browser/resources/chromeos/accessibility/switch_access/nodes/group_node.js

@@ -36,7 +36,7 @@
   /** @override */
   get location() {
     const childLocations = this.children_.map(c => c.location);
-    return RectHelper.unionAll(childLocations);
+    return RectUtil.unionAll(childLocations);
   }
 
   /** @override */
@@ -134,7 +134,7 @@
       i++;
 
       while (i < nodes.length &&
-             RectHelper.sameRow(children[0].location, nodes[i].location)) {
+             RectUtil.sameRow(children[0].location, nodes[i].location)) {
         children.push(nodes[i]);
         i++;
       }

diff --git a/chrome/browser/resources/chromeos/accessibility/switch_access/nodes/keyboard_node.js b/chrome/browser/resources/chromeos/accessibility/switch_access/nodes/keyboard_node.js
index 379fc4a..53f3e93 100644
--- a/chrome/browser/resources/chromeos/accessibility/switch_access/nodes/keyboard_node.js
+++ b/chrome/browser/resources/chromeos/accessibility/switch_access/nodes/keyboard_node.js

@@ -47,7 +47,7 @@
 
     // doDefault() does nothing on Virtual Keyboard buttons, so we must
     // simulate a mouse click.
-    const center = RectHelper.center(keyLocation);
+    const center = RectUtil.center(keyLocation);
     EventHelper.simulateMouseClick(
         center.x, center.y, SAConstants.VK_KEY_PRESS_DURATION_MS);
 

diff --git a/chrome/browser/resources/chromeos/accessibility/switch_access/nodes/switch_access_node.js b/chrome/browser/resources/chromeos/accessibility/switch_access/nodes/switch_access_node.js
index c5cf2f5f..0fde0798 100644
--- a/chrome/browser/resources/chromeos/accessibility/switch_access/nodes/switch_access_node.js
+++ b/chrome/browser/resources/chromeos/accessibility/switch_access/nodes/switch_access_node.js

@@ -224,7 +224,7 @@
 
     const loc = this.location;
     if (loc) {
-      str += 'loc(' + RectHelper.toString(loc) + ') ';
+      str += 'loc(' + RectUtil.toString(loc) + ') ';
     }
 
     if (this.isGroup()) {
@@ -299,7 +299,7 @@
     const children =
         this.children_.filter((c) => !(c instanceof BackButtonNode));
     const childLocations = children.map((c) => c.location);
-    return RectHelper.unionAll(childLocations);
+    return RectUtil.unionAll(childLocations);
   }
 
   // ================= General methods =================
@@ -413,7 +413,7 @@
 
     const loc = this.location;
     if (loc) {
-      str += 'loc(' + RectHelper.toString(loc) + ') ';
+      str += 'loc(' + RectUtil.toString(loc) + ') ';
     }
 
 

diff --git a/chrome/browser/resources/chromeos/accessibility/switch_access/nodes/tab_node.js b/chrome/browser/resources/chromeos/accessibility/switch_access/nodes/tab_node.js
index 1d2717b..3f6e85b 100644
--- a/chrome/browser/resources/chromeos/accessibility/switch_access/nodes/tab_node.js
+++ b/chrome/browser/resources/chromeos/accessibility/switch_access/nodes/tab_node.js

@@ -102,7 +102,7 @@
     if (!this.closeButton_) {
       return super.location;
     }
-    return RectHelper.difference(super.location, this.closeButton_.location);
+    return RectUtil.difference(super.location, this.closeButton_.location);
   }
 
   // ================= General methods =================

diff --git a/chrome/browser/resources/chromeos/accessibility/switch_access/nodes/tab_node_test.js b/chrome/browser/resources/chromeos/accessibility/switch_access/nodes/tab_node_test.js
index dbc6acd..61cfd6a 100644
--- a/chrome/browser/resources/chromeos/accessibility/switch_access/nodes/tab_node_test.js
+++ b/chrome/browser/resources/chromeos/accessibility/switch_access/nodes/tab_node_test.js

@@ -42,7 +42,7 @@
 
     const tabAsRoot = NavigationManager.instance.group_;
     assertTrue(
-        RectHelper.areEqual(tab.location, tabAsRoot.location),
+        RectUtil.equal(tab.location, tabAsRoot.location),
         'Tab location should not change when treated as root');
     assertEquals(
         3, tabAsRoot.children.length, 'Tab as root should have 3 children');
@@ -57,7 +57,7 @@
         tabToSelect.hasAction(SwitchAccessMenuAction.SELECT),
         'Tab as a group should have a SELECT action');
     assertFalse(
-        RectHelper.areEqual(tabAsRoot.location, tabToSelect.location),
+        RectUtil.equal(tabAsRoot.location, tabToSelect.location),
         'Tab node to select should not have the same location as tab as root');
     assertEquals(
         null, tabToSelect.asRootNode(),
@@ -74,12 +74,11 @@
         close.hasAction(SwitchAccessMenuAction.SELECT),
         'Close button should have a SELECT action');
     assertFalse(
-        RectHelper.areEqual(tabAsRoot.location, close.location),
+        RectUtil.equal(tabAsRoot.location, close.location),
         'Close button should not have the same location as tab as root');
-    const overlap =
-        RectHelper.intersection(tabToSelect.location, close.location);
+    const overlap = RectUtil.intersection(tabToSelect.location, close.location);
     assertTrue(
-        RectHelper.areEqual(RectHelper.ZERO_RECT, overlap),
+        RectUtil.equal(RectUtil.ZERO_RECT, overlap),
         'Close button and tab node to select should not overlap');
 
     BackButtonNode

diff --git a/chrome/browser/resources/chromeos/accessibility/switch_access/rect_helper.js b/chrome/browser/resources/chromeos/accessibility/switch_access/rect_helper.js
deleted file mode 100644
index f40c647..0000000
--- a/chrome/browser/resources/chromeos/accessibility/switch_access/rect_helper.js
+++ /dev/null

@@ -1,310 +0,0 @@
-// Copyright 2019 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-/** A collection of helper functions when dealing with rects. */
-const RectHelper = {
-  /** @type {!chrome.accessibilityPrivate.ScreenRect} */
-  ZERO_RECT: {top: 0, left: 0, width: 0, height: 0},
-
-  /**
-   * @param {chrome.accessibilityPrivate.ScreenRect|undefined} rect
-   * @return {number}
-   */
-  area: (rect) => rect ? rect.width * rect.height : 0,
-
-  areAdjacent: (rect1, rect2) => {
-    const verticallyStacked = rect1.top === RectHelper.bottom(rect2) ||
-        RectHelper.bottom(rect1) === rect2.top;
-    const horizontallyStacked = rect1.left === RectHelper.right(rect2) ||
-        RectHelper.right(rect1) === rect2.left;
-
-    const verticallyOverlap =
-        (rect1.top >= rect2.top && rect1.top <= RectHelper.bottom(rect2)) ||
-        (rect2.top >= rect1.top && rect2.top <= RectHelper.bottom(rect1));
-    const horizontallyOverlap =
-        (rect1.left >= rect2.left && rect1.left <= RectHelper.right(rect2)) ||
-        (rect2.left >= rect1.left && rect2.left <= RectHelper.right(rect1));
-
-    return (verticallyStacked && horizontallyOverlap) ||
-        (horizontallyStacked && verticallyOverlap);
-  },
-
-  /**
-   * Returns true if the two rects are equal.
-   *
-   * @param {chrome.accessibilityPrivate.ScreenRect=} rect1
-   * @param {chrome.accessibilityPrivate.ScreenRect=} rect2
-   * @return {boolean}
-   */
-  areEqual: (rect1, rect2) => {
-    if (!rect1 && !rect2) {
-      return true;
-    }
-    if (!rect1 || !rect2) {
-      return false;
-    }
-    return rect1.left === rect2.left && rect1.top === rect2.top &&
-        rect1.width === rect2.width && rect1.height === rect2.height;
-  },
-
-  /**
-   * Finds the bottom of a rect.
-   * @param {!chrome.accessibilityPrivate.ScreenRect} rect
-   * @return {number}
-   */
-  bottom: (rect) => rect.top + rect.height,
-
-  /**
-   * Returns the point at the center of the rectangle.
-   * @param {!chrome.accessibilityPrivate.ScreenRect} rect
-   * @return {!{x: number, y: number}} an object containing the x and y
-   *     coordinates of the center.
-   */
-  center: (rect) => {
-    const x = rect.left + Math.round(rect.width / 2);
-    const y = rect.top + Math.round(rect.height / 2);
-    return {x, y};
-  },
-
-  /**
-   * @param {chrome.accessibilityPrivate.ScreenRect} outer
-   * @param {chrome.accessibilityPrivate.ScreenRect} inner
-   * @return {boolean}
-   */
-  contains: (outer, inner) => {
-    if (!outer || !inner) {
-      return false;
-    }
-    return outer.left <= inner.left && outer.top <= inner.top &&
-        RectHelper.right(outer) >= RectHelper.right(inner) &&
-        RectHelper.bottom(outer) >= RectHelper.bottom(inner);
-  },
-
-  /**
-   * @param {!chrome.accessibilityPrivate.ScreenRect} rect
-   * @return {!chrome.accessibilityPrivate.ScreenRect}
-   */
-  deepCopy: (rect) => {
-    const copy = (Object.assign({}, rect));
-    return /** @type {!chrome.accessibilityPrivate.ScreenRect} */ (copy);
-  },
-
-  /**
-   * Returns the largest rectangle contained within the outer rect that does not
-   * overlap with the subtrahend (what is being subtracted).
-   * @param {chrome.accessibilityPrivate.ScreenRect|undefined} outer
-   * @param {chrome.accessibilityPrivate.ScreenRect|undefined} subtrahend
-   * @return {chrome.accessibilityPrivate.ScreenRect|undefined}
-   */
-  difference: (outer, subtrahend) => {
-    if (!outer || !subtrahend) {
-      return outer;
-    }
-
-    if (outer.left >= RectHelper.right(subtrahend) ||
-        RectHelper.right(outer) <= subtrahend.left ||
-        outer.top >= RectHelper.bottom(subtrahend) ||
-        RectHelper.bottom(outer) <= subtrahend.top) {
-      // If the rectangles do not overlap, return the outer rect.
-      return outer;
-    }
-
-    if (RectHelper.contains(subtrahend, outer)) {
-      // If the subtrahend contains the outer rect, there is no region that does
-      // not overlap. Return the zero rect.
-      return RectHelper.ZERO_RECT;
-    }
-
-    let above, below, toTheLeft, toTheRight;
-
-    if (outer.top < subtrahend.top) {
-      above = {
-        top: outer.top,
-        left: outer.left,
-        width: outer.width,
-        height: (subtrahend.top - outer.top)
-      };
-    }
-
-    if (RectHelper.bottom(outer) > RectHelper.bottom(subtrahend)) {
-      below = {
-        top: RectHelper.bottom(subtrahend),
-        left: outer.left,
-        width: outer.width,
-        height: (RectHelper.bottom(outer) - RectHelper.bottom(subtrahend))
-      };
-    }
-
-    if (outer.left < subtrahend.left) {
-      toTheLeft = {
-        top: outer.top,
-        left: outer.left,
-        width: (subtrahend.left - outer.left),
-        height: outer.height
-      };
-    }
-
-    if (RectHelper.right(outer) > RectHelper.right(subtrahend)) {
-      toTheRight = {
-        top: outer.top,
-        left: RectHelper.right(subtrahend),
-        width: (RectHelper.right(outer) - RectHelper.right(subtrahend)),
-        height: outer.height
-      };
-    }
-
-    // Of the four rects calculated above, find the one with the greatest area.
-    const areaAbove = RectHelper.area(above);
-    const areaBelow = RectHelper.area(below);
-    const areaToTheLeft = RectHelper.area(toTheLeft);
-    const areaToTheRight = RectHelper.area(toTheRight);
-
-    if (areaAbove > areaBelow && areaAbove > areaToTheLeft &&
-        areaAbove > areaToTheRight) {
-      return above;
-    }
-
-    if (areaBelow > areaToTheLeft && areaBelow > areaToTheRight) {
-      return below;
-    }
-
-    return areaToTheLeft > areaToTheRight ? toTheLeft : toTheRight;
-  },
-
-  /**
-   * Increases the size of |outer| to entirely enclose |inner|, with |padding|
-   * buffer on each side.
-   * @param {number} padding
-   * @param {chrome.accessibilityPrivate.ScreenRect=} outer
-   * @param {chrome.accessibilityPrivate.ScreenRect=} inner
-   * @return {chrome.accessibilityPrivate.ScreenRect|undefined}
-   */
-  expandToFitWithPadding: (padding, outer, inner) => {
-    if (!outer || !inner) {
-      return outer;
-    }
-
-    const newOuter = RectHelper.deepCopy(outer);
-
-    if (newOuter.top > inner.top - padding) {
-      newOuter.top = inner.top - padding;
-      // The height should be the original bottom point less the new top point.
-      newOuter.height = RectHelper.bottom(outer) - newOuter.top;
-    }
-    if (newOuter.left > inner.left - padding) {
-      newOuter.left = inner.left - padding;
-      // The new width should be the original right point less the new left.
-      newOuter.width = RectHelper.right(outer) - newOuter.left;
-    }
-    if (RectHelper.bottom(newOuter) < RectHelper.bottom(inner) + padding) {
-      newOuter.height = RectHelper.bottom(inner) + padding - newOuter.top;
-    }
-    if (RectHelper.right(newOuter) < RectHelper.right(inner) + padding) {
-      newOuter.width = RectHelper.right(inner) + padding - newOuter.left;
-    }
-
-    return newOuter;
-  },
-
-  /**
-   * @param {chrome.accessibilityPrivate.ScreenRect=} rect1
-   * @param {chrome.accessibilityPrivate.ScreenRect=} rect2
-   * @return {chrome.accessibilityPrivate.ScreenRect}
-   */
-  intersection: (rect1, rect2) => {
-    if (!rect1 || !rect2) {
-      return RectHelper.ZERO_RECT;
-    }
-
-    const left = Math.max(rect1.left, rect2.left);
-    const top = Math.max(rect1.top, rect2.top);
-    const right = Math.min(RectHelper.right(rect1), RectHelper.right(rect2));
-    const bottom = Math.min(RectHelper.bottom(rect1), RectHelper.bottom(rect2));
-
-    if (right <= left || bottom <= top) {
-      return RectHelper.ZERO_RECT;
-    }
-
-    const width = right - left;
-    const height = bottom - top;
-
-    return {left, top, width, height};
-  },
-
-  /**
-   * Finds the right of a rect.
-   * @param {!chrome.accessibilityPrivate.ScreenRect} rect
-   * @return {number}
-   */
-  right: (rect) => rect.left + rect.width,
-
-  /*
-   * @param {chrome.accessibilityPrivate.ScreenRect=} rect1
-   * @param {chrome.accessibilityPrivate.ScreenRect=} rect2
-   */
-  sameRow: (rect1, rect2) => {
-    if (!rect1 || !rect2) {
-      return false;
-    }
-    const bottom1 = RectHelper.bottom(rect1);
-    const middle2 = RectHelper.center(rect2).y;
-
-    return rect1.top < middle2 && bottom1 > middle2;
-  },
-
-  /**
-   * Returns a string representing the given rectangle.
-   * @param {chrome.accessibilityPrivate.ScreenRect|undefined} rect
-   * @return {string}
-   */
-  toString: (rect) => {
-    let str = '';
-    if (rect) {
-      str = rect.left + ',' + rect.top + ' ';
-      str += rect.width + 'x' + rect.height;
-    }
-    return str;
-  },
-
-  /**
-   * Returns the union of the specified rectangles.
-   * @param {!chrome.accessibilityPrivate.ScreenRect} rect1
-   * @param {!chrome.accessibilityPrivate.ScreenRect} rect2
-   * @return {!chrome.accessibilityPrivate.ScreenRect}
-   */
-  union: (rect1, rect2) => {
-    const top = rect1.top < rect2.top ? rect1.top : rect2.top;
-    const left = rect1.left < rect2.left ? rect1.left : rect2.left;
-
-    const r1Bottom = RectHelper.bottom(rect1);
-    const r2Bottom = RectHelper.bottom(rect2);
-    const bottom = r1Bottom > r2Bottom ? r1Bottom : r2Bottom;
-
-    const r1Right = RectHelper.right(rect1);
-    const r2Right = RectHelper.right(rect2);
-    const right = r1Right > r2Right ? r1Right : r2Right;
-
-    const height = bottom - top;
-    const width = right - left;
-
-    return {top, left, width, height};
-  },
-
-  /**
-   * Returns the union of all the rectangles specified.
-   * @param {!Array<!chrome.accessibilityPrivate.ScreenRect>} rects
-   * @return {!chrome.accessibilityPrivate.ScreenRect}
-   */
-  unionAll: (rects) => {
-    if (rects.length < 1) {
-      return RectHelper.ZERO_RECT;
-    }
-
-    let result = rects[0];
-    for (let i = 1; i < rects.length; i++) {
-      result = RectHelper.union(result, rects[i]);
-    }
-    return result;
-  }
-};

diff --git a/chrome/browser/resources/chromeos/accessibility/switch_access/switch_access.js b/chrome/browser/resources/chromeos/accessibility/switch_access/switch_access.js
index ba90702..8e55c247 100644
--- a/chrome/browser/resources/chromeos/accessibility/switch_access/switch_access.js
+++ b/chrome/browser/resources/chromeos/accessibility/switch_access/switch_access.js

@@ -63,32 +63,27 @@
     }
     // If it's not currently in the tree, listen for changes to the desktop
     // tree.
-    const onDesktopChildrenChanged = (event) => {
+    const eventHandler = new EventHandler(
+        desktop, chrome.automation.EventType.CHILDREN_CHANGED,
+        null /** callback */);
+
+    const onEvent = (event) => {
       if (event.target.matches(findParams)) {
         // If the event target is the node we're looking for, we've found it.
-        desktop.removeEventListener(
-            chrome.automation.EventType.CHILDREN_CHANGED,
-            onDesktopChildrenChanged, false);
+        eventHandler.stop();
         foundCallback(event.target);
       } else if (event.target.children.length > 0) {
         // Otherwise, see if one of its children is the node we're looking for.
         node = event.target.find(findParams);
         if (node) {
-          desktop.removeEventListener(
-              chrome.automation.EventType.CHILDREN_CHANGED,
-              onDesktopChildrenChanged, false);
+          eventHandler.stop();
           foundCallback(node);
         }
       }
     };
 
-    // Note: Cannot use an EventHandler here because in some cases we want
-    // to run foundCallback on the event.target, and in some cases we want to
-    // run foundCallback on one of the target's children. We would need to
-    // recalculate the interesting child twice to use EventHandler.
-    desktop.addEventListener(
-        chrome.automation.EventType.CHILDREN_CHANGED, onDesktopChildrenChanged,
-        false);
+    eventHandler.setCallback(onEvent);
+    eventHandler.start();
   }
 
   /*

diff --git a/chrome/browser/resources/chromeos/accessibility/switch_access/switch_access_predicate.js b/chrome/browser/resources/chromeos/accessibility/switch_access/switch_access_predicate.js
index 14cb6904..21780f9 100644
--- a/chrome/browser/resources/chromeos/accessibility/switch_access/switch_access_predicate.js
+++ b/chrome/browser/resources/chromeos/accessibility/switch_access/switch_access_predicate.js

@@ -134,7 +134,7 @@
         (scope instanceof SARootNode ? scope.isEquivalentTo(node) :
                                        scope === node);
     if (scope && !scopeEqualsNode &&
-        RectHelper.areEqual(node.location, scope.location)) {
+        RectUtil.equal(node.location, scope.location)) {
       cache.isGroup.set(node, false);
       return false;
     }

diff --git a/chrome/browser/resources/chromeos/accessibility/switch_access_manifest.json.jinja2 b/chrome/browser/resources/chromeos/accessibility/switch_access_manifest.json.jinja2
index b392ef7..1da93eb 100644
--- a/chrome/browser/resources/chromeos/accessibility/switch_access_manifest.json.jinja2
+++ b/chrome/browser/resources/chromeos/accessibility/switch_access_manifest.json.jinja2

@@ -17,6 +17,7 @@
       "common/automation_predicate.js",
       "common/automation_util.js",
       "common/event_handler.js",
+      "common/rect_util.js",
       "common/repeated_event_handler.js",
       "common/repeated_tree_change_handler.js",
       "common/tree_walker.js",
@@ -42,7 +43,6 @@
       "switch_access/nodes/tab_node.js",
       "switch_access/nodes/window_node.js",
       "switch_access/preferences.js",
-      "switch_access/rect_helper.js",
       "switch_access/switch_access.js",
       "switch_access/switch_access_constants.js",
       "switch_access/switch_access_predicate.js",

diff --git a/chrome/browser/resources/nearby_internals/contact_object.html b/chrome/browser/resources/nearby_internals/contact_object.html
index a92d2a0..9924d06 100644
--- a/chrome/browser/resources/nearby_internals/contact_object.html
+++ b/chrome/browser/resources/nearby_internals/contact_object.html

@@ -44,7 +44,6 @@
 <div id="item">
   <div id="header">
     <span>
-      <p>Contacts list sent? [[item.contactsPassed]]</p>
       <p>Contacts list changed? [[item.contactsListChanged]]</p>
       <p>
         Contacts added to allowlist? [[item.contactsAddedToAllowlist]]

diff --git a/chrome/browser/resources/nearby_internals/types.js b/chrome/browser/resources/nearby_internals/types.js
index 6d6d6a5..78274de 100644
--- a/chrome/browser/resources/nearby_internals/types.js
+++ b/chrome/browser/resources/nearby_internals/types.js

@@ -63,7 +63,6 @@
  * The ContactUpdate message object sent by NearbyInternalsContactsHandler
  * chrome/browser/ui/webui/nearby_internals/nearby_internals_contact_handler.cc.
  * @typedef {{time: number,
- *            contactsPassed: boolean,
  *            contactsListChanged: boolean,
  *            contactsAddedToAllowlist: boolean,
  *            contactsRemovedFromAllowlist: boolean,

diff --git a/chrome/browser/sharesheet/sharesheet_service.cc b/chrome/browser/sharesheet/sharesheet_service.cc
index 0f79520..7d4a2bb 100644
--- a/chrome/browser/sharesheet/sharesheet_service.cc
+++ b/chrome/browser/sharesheet/sharesheet_service.cc

@@ -152,10 +152,15 @@
     base::OnceCallback<void(std::vector<TargetInfo> targets)> callback,
     apps::mojom::IconValuePtr icon_value) {
   const auto& launch_entry = intent_launch_info[index];
-  targets.emplace_back(TargetType::kApp, icon_value->uncompressed,
-                       base::UTF8ToUTF16(launch_entry.app_id),
-                       base::UTF8ToUTF16(launch_entry.activity_label),
-                       launch_entry.activity_name);
+  app_service_proxy_->AppRegistryCache().ForOneApp(
+      launch_entry.app_id,
+      [&launch_entry, &targets, &icon_value](const apps::AppUpdate& update) {
+        targets.emplace_back(TargetType::kApp, icon_value->uncompressed,
+                             base::UTF8ToUTF16(launch_entry.app_id),
+                             base::UTF8ToUTF16(update.Name()),
+                             base::UTF8ToUTF16(launch_entry.activity_label),
+                             launch_entry.activity_name);
+      });
 
   LoadAppIcons(std::move(intent_launch_info), std::move(targets), index + 1,
                std::move(callback));
@@ -178,7 +183,7 @@
   while (iter != actions.end()) {
     targets.emplace_back(TargetType::kAction, (*iter)->GetActionIcon(),
                          (*iter)->GetActionName(), (*iter)->GetActionName(),
-                         base::nullopt);
+                         base::nullopt, base::nullopt);
     ++iter;
   }
 

diff --git a/chrome/browser/sharesheet/sharesheet_types.cc b/chrome/browser/sharesheet/sharesheet_types.cc
index 1d1399a..f825d79 100644
--- a/chrome/browser/sharesheet/sharesheet_types.cc
+++ b/chrome/browser/sharesheet/sharesheet_types.cc

@@ -6,15 +6,18 @@
 
 namespace sharesheet {
 
-TargetInfo::TargetInfo(TargetType type,
-                       const gfx::ImageSkia& icon,
-                       const base::string16& launch_name,
-                       const base::string16& display_name,
-                       const base::Optional<std::string>& activity_name)
+TargetInfo::TargetInfo(
+    TargetType type,
+    const gfx::ImageSkia& icon,
+    const base::string16& launch_name,
+    const base::string16& display_name,
+    const base::Optional<base::string16>& secondary_display_name,
+    const base::Optional<std::string>& activity_name)
     : type(type),
       icon(icon),
       launch_name(launch_name),
       display_name(display_name),
+      secondary_display_name(secondary_display_name),
       activity_name(activity_name) {}
 
 TargetInfo::~TargetInfo() = default;

diff --git a/chrome/browser/sharesheet/sharesheet_types.h b/chrome/browser/sharesheet/sharesheet_types.h
index 133bacd3..b6f23d0 100644
--- a/chrome/browser/sharesheet/sharesheet_types.h
+++ b/chrome/browser/sharesheet/sharesheet_types.h

@@ -26,6 +26,7 @@
              const gfx::ImageSkia& icon,
              const base::string16& launch_name,
              const base::string16& display_name,
+             const base::Optional<base::string16>& secondary_display_name,
              const base::Optional<std::string>& activity_name);
   ~TargetInfo();
 
@@ -52,6 +53,11 @@
   // bubble.
   base::string16 display_name;
 
+  // A secondary string below the |display_name| shown to the user to provide
+  // additional information for this target. This will be populated by showing
+  // the activity name in ARC apps.
+  base::Optional<base::string16> secondary_display_name;
+
   // The activity of the app for the target. This only applies when the app type
   // is kArc.
   base::Optional<std::string> activity_name;

diff --git a/chrome/browser/sharing/shared_clipboard/remote_copy_message_handler_unittest.cc b/chrome/browser/sharing/shared_clipboard/remote_copy_message_handler_unittest.cc
index fa4212c9..3ece3692 100644
--- a/chrome/browser/sharing/shared_clipboard/remote_copy_message_handler_unittest.cc
+++ b/chrome/browser/sharing/shared_clipboard/remote_copy_message_handler_unittest.cc

@@ -56,6 +56,9 @@
 
   // ui::ClipboardObserver:
   void OnClipboardDataChanged() override { callback_.Run(); }
+#if defined(OS_CHROMEOS)
+  void OnClipboardDataRead() override {}
+#endif
 
  private:
   base::RepeatingClosure callback_;

diff --git a/chrome/browser/sync/test/integration/single_client_sessions_sync_test.cc b/chrome/browser/sync/test/integration/single_client_sessions_sync_test.cc
index 62a9183..d1b949b74 100644
--- a/chrome/browser/sync/test/integration/single_client_sessions_sync_test.cc
+++ b/chrome/browser/sync/test/integration/single_client_sessions_sync_test.cc

@@ -591,10 +591,8 @@
   ExpectNavigationChain({first_url, second_url});
 }
 
-// Flaky for reasons that likely have nothing to do with the test itself. See
-// crbug.com/1043899 and crbug.com/992207.
 IN_PROC_BROWSER_TEST_F(SingleClientSessionsSyncTest,
-                       DISABLED_NavigationChainAlteredDestructively) {
+                       NavigationChainAlteredDestructively) {
   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
   ASSERT_TRUE(CheckInitialState(0));
 

diff --git a/chrome/browser/ui/android/favicon/BUILD.gn b/chrome/browser/ui/android/favicon/BUILD.gn
index f5330113..65bd38dd 100644
--- a/chrome/browser/ui/android/favicon/BUILD.gn
+++ b/chrome/browser/ui/android/favicon/BUILD.gn

@@ -1,6 +1,7 @@
 # Copyright 2020 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
+
 import("//build/config/android/rules.gni")
 
 android_library("java") {
@@ -53,11 +54,13 @@
     "java/res/drawable-xxhdpi/default_favicon.png",
     "java/res/drawable-xxxhdpi/chromelogo16.png",
     "java/res/drawable-xxxhdpi/default_favicon.png",
-    "java/res/values/colors.xml",
     "java/res/values/dimens.xml",
   ]
 
   create_srcjar = false
 
-  deps = [ "//ui/android:ui_java_resources" ]
+  deps = [
+    "//components/browser_ui/styles/android:java_resources",
+    "//ui/android:ui_java_resources",
+  ]
 }

diff --git a/chrome/browser/ui/android/favicon/java/res/values/colors.xml b/chrome/browser/ui/android/favicon/java/res/values/colors.xml
deleted file mode 100644
index 1cd2d93..0000000
--- a/chrome/browser/ui/android/favicon/java/res/values/colors.xml
+++ /dev/null

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright 2020 The Chromium Authors. All rights reserved.
-     Use of this source code is governed by a BSD-style license that can be
-     found in the LICENSE file. -->
-
-<resources>
-    <color name="default_favicon_background_color">@color/modern_grey_700</color>
-</resources>

diff --git a/chrome/browser/ui/android/strings/android_chrome_strings.grd b/chrome/browser/ui/android/strings/android_chrome_strings.grd
index cde5036..2933879 100644
--- a/chrome/browser/ui/android/strings/android_chrome_strings.grd
+++ b/chrome/browser/ui/android/strings/android_chrome_strings.grd

@@ -3256,46 +3256,6 @@
         <ph name="BEGIN_LINK">&lt;link&gt;</ph>Get help<ph name="END_LINK">&lt;/link&gt;</ph>
       </message>
 
-      <!-- Contacts Picker strings -->
-      <message name="IDS_CONTACTS_PICKER_SEARCH" desc="The hint text for the search box for contacts.">
-        Search your contacts
-      </message>
-      <message name="IDS_CONTACTS_PICKER_SELECT_CONTACTS" desc="The label at the top of the dialog that allows users to select contacts from their device and share the details with a web page.">
-        Select contacts
-      </message>
-      <message name="IDS_CONTACTS_PICKER_SELECT_CONTACT" desc="The label at the top of the dialog that allows users to select a single contact from their device and share the details with a web page.">
-        Select a contact
-      </message>
-      <message name="IDS_CONTACTS_PICKER_ALL_CONTACTS" desc="The label associated with the select all checkbox, indicating that all the contacts will be selected.">
-        All contacts
-      </message>
-      <message name="IDS_CONTACTS_PICKER_NO_CONTACTS_FOUND" desc="The label shown when no contacts are found (e.g. none exist on the device).">
-        No contacts found
-      </message>
-      <message name="IDS_TOP_VIEW_NAMES_FILTER_LABEL" desc="The label shown for the names filter toggle button (allowing the user to exclude names).">
-        Names
-      </message>
-      <message name="IDS_TOP_VIEW_ADDRESS_FILTER_LABEL" desc="The label shown for the address filter toggle button (allowing the user to exclude names).">
-        Addresses
-      </message>
-      <message name="IDS_TOP_VIEW_EMAIL_FILTER_LABEL" desc="The label shown for the email filter toggle button (allowing the user to exclude emails).">
-        Email addresses
-      </message>
-      <message name="IDS_TOP_VIEW_TELEPHONE_FILTER_LABEL" desc="The label shown for the telephone filter toggle button (allowing the user to exclude telephones).">
-        Phone numbers
-      </message>
-      <message name="IDS_TOP_VIEW_ICON_FILTER_LABEL" desc="The label shown for the icon filter toggle button (allowing the user to exclude icons).">
-        Profile photos
-      </message>
-      <message name="IDS_CONTACTS_PICKER_MORE_DETAILS" desc="Label describing that the user has one or more telephone/emails (used for either).">
-        {DETAIL_COUNT, plural,
-          =1 {(+ 1 more)}
-          other {(+ # more)}}
-      </message>
-      <message name="IDS_DISCLAIMER_SHARING_CONTACT_DETAILS" desc="Label describing what will happen with the contact details that are being shared.">
-        The contacts you select will be shared with <ph name="BEGIN_BOLD">&lt;b&gt;</ph><ph name="SITE">%1$s<ex>https://www.google.com</ex></ph><ph name="END_BOLD">&lt;/b&gt;</ph>.
-      </message>
-
       <!-- Special locale UI strings -->
       <message name="IDS_SEARCH_WITH_SOGOU" desc="Text telling the user that the search engine will be switched to Sogou.">
         Search with Sogou

diff --git a/chrome/browser/ui/app_list/app_context_menu_unittest.cc b/chrome/browser/ui/app_list/app_context_menu_unittest.cc
index 16b210c9..7635f27 100644
--- a/chrome/browser/ui/app_list/app_context_menu_unittest.cc
+++ b/chrome/browser/ui/app_list/app_context_menu_unittest.cc

@@ -598,10 +598,8 @@
 }
 
 // In suspended state app does not have launch item.
-// Disabled for being flaky. crbug.com/1115762
-TEST_P(AppContextMenuTest, DISABLED_ArcMenuSuspendedItem) {
-  apps::AppServiceTest app_service_test;
-  app_service_test.SetUp(profile());
+TEST_P(AppContextMenuTest, ArcMenuSuspendedItem) {
+  app_service_test().SetUp(profile());
   ArcAppTest arc_test;
   arc_test.SetUp(profile());
 
@@ -609,7 +607,7 @@
   app.suspended = true;
 
   arc_test.app_instance()->SendRefreshAppList({app});
-  app_service_test.FlushMojoCalls();
+  app_service_test().FlushMojoCalls();
 
   const std::string app_id = ArcAppTest::GetAppId(app);
   controller()->SetAppPinnable(app_id, AppListControllerDelegate::PIN_EDITABLE);

diff --git a/chrome/browser/ui/app_list/search/omnibox_result.cc b/chrome/browser/ui/app_list/search/omnibox_result.cc
index 982c103..29de230 100644
--- a/chrome/browser/ui/app_list/search/omnibox_result.cc
+++ b/chrome/browser/ui/app_list/search/omnibox_result.cc

@@ -232,7 +232,8 @@
     case AutocompleteMatchType::HISTORY_BODY:
     case AutocompleteMatchType::TILE_SUGGESTION:
     case AutocompleteMatchType::NUM_TYPES:
-      NOTREACHED() << match_.type;
+      // TODO(crbug.com/1028447): Add a NOTREACHED here once we are confident we
+      // know all possible types for this result.
       return ash::SEARCH_RESULT_TYPE_BOUNDARY;
   }
 }

diff --git a/chrome/browser/ui/app_list/search/search_controller_factory.cc b/chrome/browser/ui/app_list/search/search_controller_factory.cc
index a0ea622c..91dbab9 100644
--- a/chrome/browser/ui/app_list/search/search_controller_factory.cc
+++ b/chrome/browser/ui/app_list/search/search_controller_factory.cc

@@ -55,7 +55,7 @@
 // in some UI, so we need to allow returning more results than actual maximum
 // number of results to be displayed in UI.
 constexpr size_t kMaxAppsGroupResults = 7;
-constexpr size_t kMaxLauncherSearchResults = 2;
+constexpr size_t kMaxLauncherSearchResults = 4;
 // We need twice as many ZeroState and Drive file results as we need
 // duplicates of these results for the suggestion chips.
 constexpr size_t kMaxZeroStateFileResults = 20;

diff --git a/chrome/browser/ui/ash/chrome_screenshot_grabber_browsertest.cc b/chrome/browser/ui/ash/chrome_screenshot_grabber_browsertest.cc
index 9b39a40..be917d0 100644
--- a/chrome/browser/ui/ash/chrome_screenshot_grabber_browsertest.cc
+++ b/chrome/browser/ui/ash/chrome_screenshot_grabber_browsertest.cc

@@ -78,6 +78,7 @@
     clipboard_changed_ = true;
     message_loop_runner_->Quit();
   }
+  void OnClipboardDataRead() override {}
 
   void RunLoop() {
     message_loop_runner_ = new content::MessageLoopRunner;

diff --git a/chrome/browser/ui/aura/accessibility/automation_manager_aura.cc b/chrome/browser/ui/aura/accessibility/automation_manager_aura.cc
index 6479fbe..58e49ef 100644
--- a/chrome/browser/ui/aura/accessibility/automation_manager_aura.cc
+++ b/chrome/browser/ui/aura/accessibility/automation_manager_aura.cc

@@ -55,7 +55,8 @@
 
   // Send this event immediately to push the initial desktop tree state.
   pending_events_.push_back({current_tree_->GetRoot()->GetUniqueId(),
-                             ax::mojom::Event::kLoadComplete, -1});
+                             ax::mojom::Event::kLoadComplete, -1,
+                             is_performing_action_});
   SendPendingEvents();
   // Intentionally not reset at shutdown since we cannot rely on the shutdown
   // ordering of two base::Singletons.
@@ -106,6 +107,14 @@
 void AutomationManagerAura::PerformAction(const ui::AXActionData& data) {
   CHECK(enabled_);
 
+  base::AutoReset<bool> reset_is_performing_action(&is_performing_action_,
+                                                   true);
+
+  // Exclude the do default action, which can trigger too many important events
+  // that should not be ignored by clients like focus.
+  if (data.action == ax::mojom::Action::kDoDefault)
+    is_performing_action_ = false;
+
   // Unlike all of the other actions, a hit test requires determining the
   // node to perform the action on first.
   if (data.action == ax::mojom::Action::kHitTest) {
@@ -168,7 +177,8 @@
 void AutomationManagerAura::PostEvent(int id,
                                       ax::mojom::Event event_type,
                                       int action_request_id) {
-  pending_events_.push_back({id, event_type, action_request_id});
+  pending_events_.push_back(
+      {id, event_type, action_request_id, is_performing_action_});
 
   if (processing_posted_)
     return;
@@ -214,6 +224,8 @@
       ui::AXEvent event;
       event.id = aura_obj->GetUniqueId();
       event.event_type = event_type;
+      if (event_copy.is_performing_action)
+        event.event_from = ax::mojom::EventFrom::kAction;
       event.action_request_id = event_copy.action_request_id;
       events.push_back(event);
     }

diff --git a/chrome/browser/ui/aura/accessibility/automation_manager_aura.h b/chrome/browser/ui/aura/accessibility/automation_manager_aura.h
index 89145a9..9ddd824 100644
--- a/chrome/browser/ui/aura/accessibility/automation_manager_aura.h
+++ b/chrome/browser/ui/aura/accessibility/automation_manager_aura.h

@@ -82,6 +82,7 @@
 
   FRIEND_TEST_ALL_PREFIXES(AutomationManagerAuraBrowserTest, ScrollView);
   FRIEND_TEST_ALL_PREFIXES(AutomationManagerAuraBrowserTest, WebAppearsOnce);
+  FRIEND_TEST_ALL_PREFIXES(AutomationManagerAuraBrowserTest, EventFromAction);
 
   AutomationManagerAura();
   ~AutomationManagerAura() override;
@@ -120,6 +121,7 @@
     int id;
     ax::mojom::Event event_type;
     int action_request_id;
+    bool is_performing_action;
   };
 
   std::vector<Event> pending_events_;
@@ -132,6 +134,8 @@
 
   std::unique_ptr<views::AXAuraObjCache> cache_;
 
+  bool is_performing_action_ = false;
+
   DISALLOW_COPY_AND_ASSIGN(AutomationManagerAura);
 };
 

diff --git a/chrome/browser/ui/aura/accessibility/automation_manager_aura_browsertest.cc b/chrome/browser/ui/aura/accessibility/automation_manager_aura_browsertest.cc
index ef03a35..515f7a7 100644
--- a/chrome/browser/ui/aura/accessibility/automation_manager_aura_browsertest.cc
+++ b/chrome/browser/ui/aura/accessibility/automation_manager_aura_browsertest.cc

@@ -92,6 +92,13 @@
     run_loop_ = std::make_unique<base::RunLoop>();
   }
 
+  std::unique_ptr<ui::AXEvent> WaitForEvent(ax::mojom::Event event_type) {
+    event_type_to_wait_for_ = event_type;
+    run_loop_->Run();
+    run_loop_ = std::make_unique<base::RunLoop>();
+    return std::move(most_recent_event_);
+  }
+
   bool WasNodeIdFocused(int node_id) {
     for (size_t i = 0; i < focused_node_ids_.size(); i++)
       if (node_id == focused_node_ids_[i])
@@ -105,18 +112,36 @@
                                    std::vector<ui::AXTreeUpdate> updates,
                                    const gfx::Point& mouse_location,
                                    std::vector<ui::AXEvent> events) override {
-    for (const ui::AXTreeUpdate& update : updates) {
-      int focused_node_id = update.tree_data.focus_id;
-      focused_node_ids_.push_back(focused_node_id);
-      if (focused_node_id == node_id_to_wait_for_)
+    if (node_id_to_wait_for_ != -1) {
+      for (const ui::AXTreeUpdate& update : updates) {
+        int focused_node_id = update.tree_data.focus_id;
+        focused_node_ids_.push_back(focused_node_id);
+        if (focused_node_id == node_id_to_wait_for_) {
+          node_id_to_wait_for_ = -1;
+          run_loop_->Quit();
+        }
+      }
+    }
+
+    if (event_type_to_wait_for_ == ax::mojom::Event::kNone)
+      return;
+
+    for (const ui::AXEvent& event : events) {
+      if (event.event_type == event_type_to_wait_for_) {
+        most_recent_event_ = std::make_unique<ui::AXEvent>(event);
+        event_type_to_wait_for_ = ax::mojom::Event::kNone;
         run_loop_->Quit();
+      }
     }
   }
 
   std::unique_ptr<base::RunLoop> run_loop_;
-  int node_id_to_wait_for_ = 0;
+  int node_id_to_wait_for_ = -1;
   std::vector<int> focused_node_ids_;
 
+  std::unique_ptr<ui::AXEvent> most_recent_event_;
+  ax::mojom::Event event_type_to_wait_for_ = ax::mojom::Event::kNone;
+
   DISALLOW_COPY_AND_ASSIGN(AutomationEventWaiter);
 };
 
@@ -305,3 +330,55 @@
   EXPECT_EQ(50, node_data.GetIntAttribute(ax::mojom::IntAttribute::kScrollX));
   EXPECT_EQ(315, node_data.GetIntAttribute(ax::mojom::IntAttribute::kScrollY));
 }
+
+IN_PROC_BROWSER_TEST_F(AutomationManagerAuraBrowserTest, EventFromAction) {
+  auto cache = std::make_unique<views::AXAuraObjCache>();
+  auto* cache_ptr = cache.get();
+  AutomationManagerAura* manager = AutomationManagerAura::GetInstance();
+  manager->set_ax_aura_obj_cache_for_testing(std::move(cache));
+  manager->Enable();
+
+  views::Widget* widget = new views::Widget;
+  views::Widget::InitParams params(views::Widget::InitParams::TYPE_WINDOW);
+  params.bounds = {0, 0, 200, 200};
+  widget->Init(std::move(params));
+  widget->Show();
+  widget->Activate();
+
+  cache_ptr->set_focused_widget_for_testing(widget);
+
+  views::View* view1 = new views::View();
+  view1->GetViewAccessibility().OverrideName("view1");
+  view1->SetFocusBehavior(views::View::FocusBehavior::ALWAYS);
+  widget->GetRootView()->AddChildView(view1);
+  views::View* view2 = new views::View();
+  view2->SetFocusBehavior(views::View::FocusBehavior::ALWAYS);
+  view2->GetViewAccessibility().OverrideName("view2");
+  widget->GetRootView()->AddChildView(view2);
+  views::AXAuraObjWrapper* wrapper2 = cache_ptr->GetOrCreate(view2);
+
+  AutomationEventWaiter waiter;
+
+  // Focus view1, simulating the non-accessibility action, block until we get an
+  // accessibility event that shows this view is focused.
+  view1->RequestFocus();
+  auto event_from_views = waiter.WaitForEvent(ax::mojom::Event::kFocus);
+  ASSERT_NE(nullptr, event_from_views.get());
+  EXPECT_EQ(ax::mojom::EventFrom::kNone, event_from_views->event_from);
+
+  // Focus view2, simulating the accessibility action, block until we get an
+  // accessibility event that shows this view is focused.
+  ui::AXActionData action_data;
+  action_data.action = ax::mojom::Action::kFocus;
+  action_data.target_tree_id = manager->current_tree_.get()->tree_id_for_test();
+  action_data.target_node_id = wrapper2->GetUniqueId();
+
+  manager->PerformAction(action_data);
+  auto event_from_action = waiter.WaitForEvent(ax::mojom::Event::kFocus);
+  ASSERT_NE(nullptr, event_from_action.get());
+  EXPECT_EQ(ax::mojom::EventFrom::kAction, event_from_action->event_from);
+
+  cache_ptr->set_focused_widget_for_testing(nullptr);
+
+  AddFailureOnWidgetAccessibilityError(widget);
+}

diff --git a/chrome/browser/ui/keyboard_lock_interactive_browsertest.cc b/chrome/browser/ui/keyboard_lock_interactive_browsertest.cc
index 0df45dc1..3608b25b 100644
--- a/chrome/browser/ui/keyboard_lock_interactive_browsertest.cc
+++ b/chrome/browser/ui/keyboard_lock_interactive_browsertest.cc

@@ -260,7 +260,8 @@
 }
 
 // https://crbug.com/1108391 Flakey on ChromeOS.
-#if defined(OS_CHROMEOS)
+// https://crbug.com/1121172 Also flaky on Lacros.
+#if defined(OS_CHROMEOS) || BUILDFLAG(IS_LACROS)
 #define MAYBE_SubsequentLockCallSupersedesPreviousCall \
   DISABLED_SubsequentLockCallSupersedesPreviousCall
 #else

diff --git a/chrome/browser/ui/ui_features.cc b/chrome/browser/ui/ui_features.cc
index cc6f63a..ab19a0ce 100644
--- a/chrome/browser/ui/ui_features.cc
+++ b/chrome/browser/ui/ui_features.cc

@@ -27,12 +27,6 @@
 const base::Feature kForceEnableDevicesPage{"ForceEnableDevicesPage",
                                             base::FEATURE_DISABLED_BY_DEFAULT};
 
-// Enables tabs from different browser types (NORMAL vs APP) and different apps
-// to mix via dragging.
-// https://crbug.com/1012169
-const base::Feature kMixBrowserTypeTabs{"MixBrowserTypeTabs",
-                                        base::FEATURE_DISABLED_BY_DEFAULT};
-
 // Enables the new profile picker.
 // https:://crbug.com/1063856
 const base::Feature kNewProfilePicker{"NewProfilePicker",

diff --git a/chrome/browser/ui/ui_features.h b/chrome/browser/ui/ui_features.h
index 97ec57d..2aac982 100644
--- a/chrome/browser/ui/ui_features.h
+++ b/chrome/browser/ui/ui_features.h

@@ -28,8 +28,6 @@
 
 extern const base::Feature kForceEnableDevicesPage;
 
-extern const base::Feature kMixBrowserTypeTabs;
-
 extern const base::Feature kNewProfilePicker;
 
 extern const base::Feature kNewTabstripAnimation;

diff --git a/chrome/browser/ui/views/download/download_item_view.cc b/chrome/browser/ui/views/download/download_item_view.cc
index 86b58f0..7bf9115 100644
--- a/chrome/browser/ui/views/download/download_item_view.cc
+++ b/chrome/browser/ui/views/download/download_item_view.cc

@@ -299,6 +299,9 @@
   complete_animation_.SetSlideDuration(base::TimeDelta::FromMilliseconds(2500));
   complete_animation_.SetTweenType(gfx::Tween::LINEAR);
 
+  scanning_animation_.SetThrobDuration(base::TimeDelta::FromMilliseconds(2500));
+  scanning_animation_.SetTweenType(gfx::Tween::LINEAR);
+
   // Further configure default state, e.g. child visibility.
   OnDownloadUpdated();
 }
@@ -607,6 +610,15 @@
         static_cast<uint8_t>(gfx::Tween::IntValueBetween(opacity, 0, 255)));
     PaintDownloadProgress(canvas, progress_bounds, base::TimeDelta(), 100);
     canvas->Restore();
+  } else if (scanning_animation_.is_animating()) {
+    DCHECK_EQ(Mode::kDeepScanning, mode_);
+    const double value = gfx::Tween::DoubleValueBetween(
+        scanning_animation_.GetCurrentValue(), 0, 2 * base::kPiDouble);
+    const double opacity = std::sin(value + base::kPiDouble / 2) / 2 + 0.5;
+    canvas->SaveLayerAlpha(
+        static_cast<uint8_t>(gfx::Tween::IntValueBetween(opacity, 0, 255)));
+    PaintDownloadProgress(canvas, GetIconBounds(), base::TimeDelta(), 100);
+    canvas->Restore();
   } else if (use_new_warnings) {
     file_icon = &file_icon_;
   }
@@ -624,14 +636,10 @@
 
   // Overlay the warning icon if appropriate.
   if (mode_ != Mode::kNormal) {
-    const int offset = use_new_warnings ? 8 : 0;
     const gfx::ImageSkia icon = ui::ThemedVectorIcon(GetIcon().GetVectorIcon())
                                     .GetImageSkia(GetNativeTheme());
-    const int icon_x =
-        GetMirroredXWithWidthInView(kStartPadding, icon.size().width()) +
-        offset;
-    const int icon_y = CenterY(icon.size().height()) + offset;
-    canvas->DrawImageInt(icon, icon_x, icon_y);
+    gfx::RectF bounds = GetIconBounds();
+    canvas->DrawImageInt(icon, bounds.x(), bounds.y());
   }
 
   OnPaintBorder(canvas);
@@ -679,6 +687,7 @@
   UpdateFilePathAndIcons();
   UpdateLabels();
   UpdateButtons();
+  UpdateAnimationForDeepScanningMode();
 
   // Update the accessible name to contain the status text, filename, and
   // warning message (if any). The name will be presented when the download item
@@ -866,6 +875,15 @@
   }
 }
 
+void DownloadItemView::UpdateAnimationForDeepScanningMode() {
+  if (mode_ == Mode::kDeepScanning) {
+    // -1 to throb indefinitely.
+    scanning_animation_.StartThrobbing(-1);
+  } else {
+    scanning_animation_.End();
+  }
+}
+
 base::string16 DownloadItemView::GetInProgressAccessibleAlertText() const {
   // If opening when complete or there is a warning, use the full status text.
   if (model_->GetOpenWhenComplete() || has_warning_label(mode_))
@@ -1024,6 +1042,17 @@
   return ui::ImageModel();
 }
 
+gfx::RectF DownloadItemView::GetIconBounds() const {
+  // TODO(drubery): When launching the new warnings, turn these numbers into
+  // appropriately named constants.
+  const int offset = UseNewWarnings() ? 8 : 0;
+  const gfx::Size size = GetIcon().Size();
+  const int icon_x =
+      GetMirroredXWithWidthInView(kStartPadding, size.width()) + offset;
+  const int icon_y = CenterY(size.height()) + offset;
+  return gfx::RectF(icon_x, icon_y, size.width(), size.height());
+}
+
 std::pair<base::string16, int> DownloadItemView::GetStatusTextAndStyle() const {
   using DangerType = download::DownloadDangerType;
   const auto type = model_->GetDangerType();

diff --git a/chrome/browser/ui/views/download/download_item_view.h b/chrome/browser/ui/views/download/download_item_view.h
index d0a9ca5..108df896 100644
--- a/chrome/browser/ui/views/download/download_item_view.h
+++ b/chrome/browser/ui/views/download/download_item_view.h

@@ -25,6 +25,7 @@
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/gfx/animation/slide_animation.h"
+#include "ui/gfx/animation/throb_animation.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_skia.h"
@@ -140,6 +141,10 @@
   // Update accessible status text, and announce it if desired.
   void UpdateAccessibleAlert(const base::string16& alert);
 
+  // Updates the animation used during deep scanning. The animation is started
+  // or stopped depending on the current mode.
+  void UpdateAnimationForDeepScanningMode();
+
   // Get the accessible alert text for a download that is currently in progress.
   base::string16 GetInProgressAccessibleAlertText() const;
 
@@ -162,6 +167,9 @@
   // When not in normal mode, returns the current help/warning/error icon.
   ui::ImageModel GetIcon() const;
 
+  // When not in nromal mode, returns the bounds of the current icon.
+  gfx::RectF GetIconBounds() const;
+
   // Returns the text and style to use for the status label.
   std::pair<base::string16, int> GetStatusTextAndStyle() const;
 
@@ -270,6 +278,8 @@
 
   gfx::SlideAnimation complete_animation_{this};
 
+  gfx::ThrobAnimation scanning_animation_{this};
+
   // The tooltip.  Only displayed when not showing a warning dialog.
   base::string16 tooltip_text_;
 

diff --git a/chrome/browser/ui/views/intent_picker_bubble_view.h b/chrome/browser/ui/views/intent_picker_bubble_view.h
index a8e57f1..5f387868c 100644
--- a/chrome/browser/ui/views/intent_picker_bubble_view.h
+++ b/chrome/browser/ui/views/intent_picker_bubble_view.h

@@ -113,6 +113,8 @@
   FRIEND_TEST_ALL_PREFIXES(IntentPickerBubbleViewTest, WebContentsTiedToBubble);
   FRIEND_TEST_ALL_PREFIXES(IntentPickerBubbleViewTest, WindowTitle);
   FRIEND_TEST_ALL_PREFIXES(IntentPickerBubbleViewTest, ButtonLabels);
+  FRIEND_TEST_ALL_PREFIXES(IntentPickerBubbleViewBrowserTestChromeOS,
+                           BubblePopOut);
 
   static std::unique_ptr<IntentPickerBubbleView> CreateBubbleViewForTesting(
       views::View* anchor_view,

diff --git a/chrome/browser/ui/views/intent_picker_bubble_view_browsertest_chromeos.cc b/chrome/browser/ui/views/intent_picker_bubble_view_browsertest_chromeos.cc
new file mode 100644
index 0000000..77dae26
--- /dev/null
+++ b/chrome/browser/ui/views/intent_picker_bubble_view_browsertest_chromeos.cc

@@ -0,0 +1,98 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "chrome/browser/ui/views/intent_picker_bubble_view.h"
+
+#include "base/test/scoped_feature_list.h"
+#include "chrome/browser/apps/app_service/app_service_proxy.h"
+#include "chrome/browser/apps/app_service/app_service_proxy_factory.h"
+#include "chrome/browser/apps/app_service/app_service_test.h"
+#include "chrome/browser/ui/browser.h"
+#include "chrome/browser/ui/browser_commands.h"
+#include "chrome/browser/ui/browser_navigator_params.h"
+#include "chrome/browser/ui/views/frame/browser_view.h"
+#include "chrome/browser/ui/views/frame/toolbar_button_provider.h"
+#include "chrome/browser/ui/views/location_bar/intent_picker_view.h"
+#include "chrome/common/chrome_features.h"
+#include "chrome/test/base/in_process_browser_test.h"
+#include "chrome/test/base/ui_test_utils.h"
+#include "components/services/app_service/public/cpp/intent_filter_util.h"
+#include "components/services/app_service/public/cpp/intent_test_util.h"
+#include "components/services/app_service/public/cpp/intent_util.h"
+#include "components/services/app_service/public/mojom/types.mojom.h"
+#include "content/public/test/browser_test.h"
+#include "url/gurl.h"
+#include "url/url_constants.h"
+
+namespace {
+const char kAppId1[] = "abcdefg";
+}  // namespace
+
+class IntentPickerBubbleViewBrowserTestChromeOS : public InProcessBrowserTest {
+ public:
+  void SetUpOnMainThread() override {
+    InProcessBrowserTest::SetUpOnMainThread();
+    app_service_test_.SetUp(browser()->profile());
+    app_service_proxy_ =
+        apps::AppServiceProxyFactory::GetForProfile(browser()->profile());
+    ASSERT_TRUE(app_service_proxy_);
+  }
+
+  void AddFakeAppWithIntentFilter(const std::string& app_id,
+                                  const std::string& app_name,
+                                  const GURL& url,
+                                  const apps::mojom::AppType app_type) {
+    std::vector<apps::mojom::AppPtr> apps;
+    auto app = apps::mojom::App::New();
+    app->app_id = app_id;
+    app->app_type = app_type;
+    app->name = app_name;
+    auto intent_filter = apps_util::CreateIntentFilterForUrlScope(url);
+    app->intent_filters.push_back(std::move(intent_filter));
+    apps.push_back(std::move(app));
+    app_service_proxy_->AppRegistryCache().OnApps(std::move(apps));
+    app_service_test_.WaitForAppService();
+  }
+
+  PageActionIconView* GetIntentPickerIcon() {
+    return BrowserView::GetBrowserViewForBrowser(browser())
+        ->toolbar_button_provider()
+        ->GetPageActionIconView(PageActionIconType::kIntentPicker);
+  }
+
+  apps::AppServiceTest& app_service_test() { return app_service_test_; }
+
+ private:
+  apps::AppServiceProxy* app_service_proxy_ = nullptr;
+  apps::AppServiceTest app_service_test_;
+};
+
+IN_PROC_BROWSER_TEST_F(IntentPickerBubbleViewBrowserTestChromeOS,
+                       BubblePopOut) {
+  GURL test_url("https://www.google.com/");
+  std::string app_name = "test_name";
+  AddFakeAppWithIntentFilter(kAppId1, app_name, test_url,
+                             apps::mojom::AppType::kArc);
+  PageActionIconView* intent_picker_view = GetIntentPickerIcon();
+
+  chrome::NewTab(browser());
+  ui_test_utils::NavigateToURL(browser(), GURL(url::kAboutBlankURL));
+
+  // Navigate from a link.
+  NavigateParams params(browser(), test_url,
+                        ui::PageTransition::PAGE_TRANSITION_LINK);
+
+  // Navigates and waits for loading to finish.
+  ui_test_utils::NavigateToURL(&params);
+  app_service_test().WaitForAppService();
+  EXPECT_TRUE(intent_picker_view->GetVisible());
+  EXPECT_TRUE(IntentPickerBubbleView::intent_picker_bubble_);
+  EXPECT_EQ(1U,
+            IntentPickerBubbleView::intent_picker_bubble_->GetScrollViewSize());
+  auto& app_info =
+      IntentPickerBubbleView::intent_picker_bubble_->app_info_for_testing();
+  ASSERT_EQ(1U, app_info.size());
+  EXPECT_EQ(kAppId1, app_info[0].launch_name);
+  EXPECT_EQ(app_name, app_info[0].display_name);
+}

diff --git a/chrome/browser/ui/views/sharesheet_bubble_view.cc b/chrome/browser/ui/views/sharesheet_bubble_view.cc
index fde41dbc..4fc5451 100644
--- a/chrome/browser/ui/views/sharesheet_bubble_view.cc
+++ b/chrome/browser/ui/views/sharesheet_bubble_view.cc

@@ -43,19 +43,24 @@
 constexpr int kButtonPadding = 8;
 
 constexpr int kBubbleTopPaddingFromWindow = 36;
-
 constexpr int kCornerRadius = 12;
 constexpr int kMaxTargetsPerRow = 4;
 // TargetViewHeight is 2*kButtonHeight + kButtonPadding
 constexpr int kTargetViewHeight = 216;
 constexpr int kDefaultBubbleWidth = 416;
+constexpr int kDefaultBubbleHeight = 328;
 constexpr int kShortSpacing = 20;
 constexpr int kSpacing = 24;
 constexpr int kTitleLineHeight = 24;
+
 constexpr char kTitle[] = "Share";
+constexpr char kTitleFont[] = "GoogleSans, Medium, 16px";
+constexpr char kButtonLabelFont[] = "Roboto, Medium, 14px";
+constexpr char kButtonSecondaryLabelFont[] = "Roboto, Regular, 13px";
 
 constexpr SkColor kShareTitleColor = gfx::kGoogleGrey900;
 constexpr SkColor kShareTargetTitleColor = gfx::kGoogleGrey700;
+constexpr SkColor kShareTargetSecondaryTitleColor = gfx::kGoogleGrey600;
 
 enum { COLUMN_SET_ID_TITLE, COLUMN_SET_ID_TARGETS };
 
@@ -68,6 +73,7 @@
  public:
   ShareSheetTargetButton(views::ButtonListener* listener,
                          const base::string16& display_name,
+                         const base::string16& secondary_display_name,
                          const gfx::ImageSkia* icon)
       : Button(listener) {
     auto* layout = SetLayoutManager(std::make_unique<views::BoxLayout>(
@@ -85,16 +91,26 @@
       image->SetImage(icon);
     }
 
-    auto* label = AddChildView(std::make_unique<views::Label>(display_name));
-    label->SetFontList(gfx::FontList("Roboto, Medium, 14px"));
-    label->SetLineHeight(kButtonLineHeight);
-    label->SetBackgroundColor(SK_ColorTRANSPARENT);
+    auto label_view = std::make_unique<views::View>();
+    label_view->SetLayoutManager(std::make_unique<views::BoxLayout>(
+        views::BoxLayout::Orientation::kVertical, gfx::Insets(), 0, true));
+
+    auto* label =
+        label_view->AddChildView(std::make_unique<views::Label>(display_name));
+    label->SetFontList(gfx::FontList(kButtonLabelFont));
     label->SetEnabledColor(kShareTargetTitleColor);
-    label->SetHandlesTooltips(true);
-    label->SetTooltipText(display_name);
-    label->SetMultiLine(false);
-    label->SetAutoColorReadabilityEnabled(false);
-    label->SetHorizontalAlignment(gfx::ALIGN_CENTER);
+    SetLabelProperties(label);
+
+    if (secondary_display_name != base::string16() &&
+        secondary_display_name != display_name) {
+      auto* secondary_label = label_view->AddChildView(
+          std::make_unique<views::Label>(secondary_display_name));
+      secondary_label->SetFontList(gfx::FontList(kButtonSecondaryLabelFont));
+      secondary_label->SetEnabledColor(kShareTargetSecondaryTitleColor);
+      SetLabelProperties(secondary_label);
+    }
+
+    AddChildView(std::move(label_view));
 
     SetFocusForPlatform();
   }
@@ -102,6 +118,16 @@
   ShareSheetTargetButton(const ShareSheetTargetButton&) = delete;
   ShareSheetTargetButton& operator=(const ShareSheetTargetButton&) = delete;
 
+  void SetLabelProperties(views::Label* label) {
+    label->SetLineHeight(kButtonLineHeight);
+    label->SetBackgroundColor(SK_ColorTRANSPARENT);
+    label->SetHandlesTooltips(true);
+    label->SetTooltipText(label->GetText());
+    label->SetMultiLine(false);
+    label->SetAutoColorReadabilityEnabled(false);
+    label->SetHorizontalAlignment(gfx::ALIGN_CENTER);
+  }
+
   // Button is 76px width x 88px height + 8px padding along all sides.
   gfx::Size CalculatePreferredSize() const override {
     return gfx::Size(kButtonWidth, kButtonHeight);
@@ -158,7 +184,7 @@
                         kTitleLineHeight);
   auto* title = main_layout->AddView(std::make_unique<views::Label>(
       base::UTF8ToUTF16(base::StringPiece(kTitle))));
-  title->SetFontList(gfx::FontList("GoogleSans, Medium, 24px"));
+  title->SetFontList(gfx::FontList(kTitleFont));
   title->SetLineHeight(kTitleLineHeight);
   title->SetEnabledColor(kShareTitleColor);
   title->SetHorizontalAlignment(gfx::ALIGN_LEFT);
@@ -186,8 +212,14 @@
       scroll_layout->StartRow(views::GridLayout::kFixedSize,
                               COLUMN_SET_ID_TARGETS);
     }
+
+    auto secondary_display_name = base::string16();
+    if (target.secondary_display_name.has_value() &&
+        !target.secondary_display_name.value().empty()) {
+      secondary_display_name = target.secondary_display_name.value();
+    }
     auto target_view = std::make_unique<ShareSheetTargetButton>(
-        this, target.display_name, &target.icon);
+        this, target.display_name, secondary_display_name, &target.icon);
     target_view->set_tag(i++);
     scroll_layout->AddView(std::move(target_view));
   }
@@ -273,8 +305,10 @@
 
   auto root_view = std::make_unique<views::View>();
   root_view->SetLayoutManager(std::make_unique<views::BoxLayout>(
-      views::BoxLayout::Orientation::kVertical, gfx::Insets(kSpacing), 0,
-      true));
+      views::BoxLayout::Orientation::kVertical,
+      gfx::Insets(/* top */ kSpacing, /* left */ kSpacing,
+                  /* bottom */ kShortSpacing, /* right */ kSpacing),
+      0, true));
   root_view_ = AddChildView(std::move(root_view));
 
   auto main_view = std::make_unique<views::View>();
@@ -308,5 +342,5 @@
 
 void SharesheetBubbleView::SetToDefaultBubbleSizing() {
   width_ = kDefaultBubbleWidth;
-  height_ = GetHeightForWidth(width_);
+  height_ = kDefaultBubbleHeight;
 }

diff --git a/chrome/browser/ui/views/sharing/remote_copy_browsertest.cc b/chrome/browser/ui/views/sharing/remote_copy_browsertest.cc
index b7182e7..a8c03c18 100644
--- a/chrome/browser/ui/views/sharing/remote_copy_browsertest.cc
+++ b/chrome/browser/ui/views/sharing/remote_copy_browsertest.cc

@@ -55,6 +55,9 @@
       : callback_(callback) {}
 
   void OnClipboardDataChanged() override { callback_.Run(); }
+#if defined(OS_CHROMEOS)
+  void OnClipboardDataRead() override {}
+#endif
 
  private:
   base::RepeatingClosure callback_;

diff --git a/chrome/browser/ui/views/tab_search/tab_search_bubble_view.cc b/chrome/browser/ui/views/tab_search/tab_search_bubble_view.cc
index 2a66d42a5..cf28639 100644
--- a/chrome/browser/ui/views/tab_search/tab_search_bubble_view.cc
+++ b/chrome/browser/ui/views/tab_search/tab_search_bubble_view.cc

@@ -8,6 +8,7 @@
 #include "base/timer/elapsed_timer.h"
 #include "chrome/browser/ui/webui/tab_search/tab_search_ui.h"
 #include "chrome/common/webui_url_constants.h"
+#include "ui/gfx/geometry/rounded_corners_f.h"
 #include "ui/views/controls/webview/webview.h"
 #include "ui/views/layout/fill_layout.h"
 #include "ui/views/widget/widget.h"
@@ -112,6 +113,11 @@
   return preferred_size;
 }
 
+void TabSearchBubbleView::AddedToWidget() {
+  BubbleDialogDelegateView::AddedToWidget();
+  web_view_->holder()->SetCornerRadii(gfx::RoundedCornersF(GetCornerRadius()));
+}
+
 void TabSearchBubbleView::OnWebViewSizeChanged() {
   SizeToContents();
 }

diff --git a/chrome/browser/ui/views/tab_search/tab_search_bubble_view.h b/chrome/browser/ui/views/tab_search/tab_search_bubble_view.h
index 29e2af2..dfb0f98 100644
--- a/chrome/browser/ui/views/tab_search/tab_search_bubble_view.h
+++ b/chrome/browser/ui/views/tab_search/tab_search_bubble_view.h

@@ -41,6 +41,7 @@
 
   // views::BubbleDialogDelegateView:
   gfx::Size CalculatePreferredSize() const override;
+  void AddedToWidget() override;
 
   void OnWebViewSizeChanged();
 

diff --git a/chrome/browser/ui/views/tabs/tab.cc b/chrome/browser/ui/views/tabs/tab.cc
index 50afe31..83651a9 100644
--- a/chrome/browser/ui/views/tabs/tab.cc
+++ b/chrome/browser/ui/views/tabs/tab.cc

@@ -348,8 +348,7 @@
     const int left = std::min(after_title_padding, close_x);
     const int bottom = height() - close_button_size - top;
     const int right = std::max(0, width() - (close_x + close_button_size));
-    close_button_->SetBorder(
-        views::CreateEmptyBorder(top, left, bottom, right));
+    close_button_->SetButtonPadding(gfx::Insets(top, left, bottom, right));
     close_button_->SetBoundsRect(
         {gfx::Point(close_x - left, 0), close_button_->GetPreferredSize()});
   }

diff --git a/chrome/browser/ui/views/tabs/tab_close_button.cc b/chrome/browser/ui/views/tabs/tab_close_button.cc
index ee9a958..c14ff9b 100644
--- a/chrome/browser/ui/views/tabs/tab_close_button.cc
+++ b/chrome/browser/ui/views/tabs/tab_close_button.cc

@@ -27,6 +27,7 @@
 #include "ui/views/controls/highlight_path_generator.h"
 #include "ui/views/layout/layout_provider.h"
 #include "ui/views/rect_based_targeting_utils.h"
+#include "ui/views/view_class_properties.h"
 
 #if defined(USE_AURA)
 #include "ui/aura/env.h"
@@ -73,6 +74,10 @@
       std::make_unique<views::CircleHighlightPathGenerator>(gfx::Insets());
   ring_highlight_path->set_use_contents_bounds(true);
   focus_ring()->SetPathGenerator(std::move(ring_highlight_path));
+
+  // Always have a value on this property so we can modify it directly without
+  // a heap allocation.
+  SetProperty(views::kInternalPaddingKey, gfx::Insets());
 }
 
 TabCloseButton::~TabCloseButton() {}
@@ -90,6 +95,10 @@
       color_utils::GetColorWithMaxContrast(background_color));
 }
 
+void TabCloseButton::SetButtonPadding(const gfx::Insets& padding) {
+  *GetProperty(views::kInternalPaddingKey) = padding;
+}
+
 const char* TabCloseButton::GetClassName() const {
   return "TabCloseButton";
 }
@@ -130,12 +139,13 @@
   event->SetHandled();
 }
 
+gfx::Insets TabCloseButton::GetInsets() const {
+  return ImageButton::GetInsets() + *GetProperty(views::kInternalPaddingKey);
+}
+
 gfx::Size TabCloseButton::CalculatePreferredSize() const {
-  int width = GetGlyphSize();
-  gfx::Size size(width, width);
-  gfx::Insets insets = GetInsets();
-  size.Enlarge(insets.width(), insets.height());
-  return size;
+  const int glyph_size = GetGlyphSize();
+  return gfx::Size(glyph_size, glyph_size) + GetInsets().size();
 }
 
 void TabCloseButton::PaintButtonContents(gfx::Canvas* canvas) {

diff --git a/chrome/browser/ui/views/tabs/tab_close_button.h b/chrome/browser/ui/views/tabs/tab_close_button.h
index 645e7c0c..d7cb86e2 100644
--- a/chrome/browser/ui/views/tabs/tab_close_button.h
+++ b/chrome/browser/ui/views/tabs/tab_close_button.h

@@ -39,6 +39,13 @@
   // theme changes.
   void SetIconColors(SkColor foreground_color, SkColor background_color);
 
+  // Sets the desired padding around the icon. Only the icon is a target for
+  // mouse clicks, but the entire button is a target for touch events, since the
+  // button itself is small. Note that this is cheaper than, for example,
+  // installing a new EmptyBorder every time we want to change the padding
+  // around the icon.
+  void SetButtonPadding(const gfx::Insets& padding);
+
   // views::ImageButton:
   const char* GetClassName() const override;
   View* GetTooltipHandlerForPoint(const gfx::Point& point) override;
@@ -46,6 +53,7 @@
   void OnMouseReleased(const ui::MouseEvent& event) override;
   void OnMouseMoved(const ui::MouseEvent& event) override;
   void OnGestureEvent(ui::GestureEvent* event) override;
+  gfx::Insets GetInsets() const override;
 
  protected:
   // views::ImageButton:

diff --git a/chrome/browser/ui/views/tabs/tab_drag_controller.cc b/chrome/browser/ui/views/tabs/tab_drag_controller.cc
index 879ac76..9f394def 100644
--- a/chrome/browser/ui/views/tabs/tab_drag_controller.cc
+++ b/chrome/browser/ui/views/tabs/tab_drag_controller.cc

@@ -2284,14 +2284,11 @@
   if (other_browser->profile() != browser->profile())
     return false;
 
-  // Unless we allow Feature mix-browser-type-tabs, ensure that
-  // browser types and app names are the same.
-  if (!base::FeatureList::IsEnabled(features::kMixBrowserTypeTabs)) {
-    if (other_browser->type() != browser->type() ||
-        (browser->is_type_app() &&
-         browser->app_name() != other_browser->app_name())) {
-      return false;
-    }
+  // Ensure that browser types and app names are the same.
+  if (other_browser->type() != browser->type() ||
+      (browser->is_type_app() &&
+       browser->app_name() != other_browser->app_name())) {
+    return false;
   }
 
   return true;

diff --git a/chrome/browser/ui/views/tabs/tab_drag_controller_interactive_uitest.cc b/chrome/browser/ui/views/tabs/tab_drag_controller_interactive_uitest.cc
index 7c25f93..2aa16412 100644
--- a/chrome/browser/ui/views/tabs/tab_drag_controller_interactive_uitest.cc
+++ b/chrome/browser/ui/views/tabs/tab_drag_controller_interactive_uitest.cc

@@ -437,9 +437,7 @@
       public ::testing::WithParamInterface<const char*> {
  public:
   DetachToBrowserTabDragControllerTest() {
-    scoped_feature_list_.InitWithFeatures(
-        {features::kMixBrowserTypeTabs} /* enabled_features */,
-        {features::kWebUITabStrip} /* disabled_features */);
+    scoped_feature_list_.InitAndDisableFeature(features::kWebUITabStrip);
   }
   DetachToBrowserTabDragControllerTest(
       const DetachToBrowserTabDragControllerTest&) = delete;
@@ -3533,38 +3531,6 @@
   EXPECT_EQ("1", IDString(app_browser1->tab_strip_model()));
 }
 
-// Move tab from TYPE_APP Browser to TYPE_NORMAL Browser.
-// Only allowed with feature MixBrowserTypeTabs.
-IN_PROC_BROWSER_TEST_P(DetachToBrowserTabDragControllerTestWithTabbedSystemApp,
-                       DragAppToNormalWindow) {
-  // Install and get a tabbed system app.
-  web_app::AppId tabbed_app_id = InstallMockApp();
-  Browser* app_browser = LaunchWebAppBrowser(tabbed_app_id);
-  ASSERT_EQ(2u, browser_list->size());
-  // Close normal browser since other code expects only 1 browser to start.
-  CloseBrowserSynchronously(browser());
-  ASSERT_EQ(1u, browser_list->size());
-  SelectFirstBrowser();
-
-  Browser* browser2 = CreateAnotherBrowserAndResize();
-  ResetIDs(browser2->tab_strip_model(), 100);
-
-  AddTabsAndResetBrowser(browser(), 1, GetAppUrl());
-  TabStrip* tab_strip1 = GetTabStripForBrowser(app_browser);
-  TabStrip* tab_strip2 = GetTabStripForBrowser(browser2);
-
-  // Move to the first tab and drag it enough so that it detaches, but not
-  // enough that it attaches to browser2.
-  DragTabAndNotify(tab_strip1, base::BindOnce(&DragToSeparateWindowStep2, this,
-                                              tab_strip1, tab_strip2));
-
-  // Should now be attached to tab_strip2.
-  // Release mouse or touch, stopping the drag session.
-  ASSERT_TRUE(ReleaseInput());
-  EXPECT_EQ("100 0", IDString(browser2->tab_strip_model()));
-  EXPECT_EQ("1", IDString(app_browser->tab_strip_model()));
-}
-
 // Subclass of DetachToBrowserTabDragControllerTest that
 // creates multiple displays.
 class DetachToBrowserInSeparateDisplayTabDragControllerTest

diff --git a/chrome/browser/ui/webui/chrome_web_ui_controller_factory.cc b/chrome/browser/ui/webui/chrome_web_ui_controller_factory.cc
index aa93a9d..b10b0b72 100644
--- a/chrome/browser/ui/webui/chrome_web_ui_controller_factory.cc
+++ b/chrome/browser/ui/webui/chrome_web_ui_controller_factory.cc

@@ -23,6 +23,7 @@
 #include "chrome/browser/media/media_engagement_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
+#include "chrome/browser/search/ntp_features.h"
 #include "chrome/browser/search/suggestions/suggestions_ui.h"
 #include "chrome/browser/ui/webui/about_ui.h"
 #include "chrome/browser/ui/webui/autofill_and_password_manager_internals/autofill_internals_ui.h"
@@ -1018,7 +1019,8 @@
       // https://crbug.com/859345
       origin.host() == chrome::kChromeUIDownloadsHost ||
       // TODO(crbug.com/1076506): remove when change to iframed OneGoogleBar.
-      origin.host() == chrome::kChromeUINewTabPageHost;
+      (origin.host() == chrome::kChromeUINewTabPageHost &&
+       !base::FeatureList::IsEnabled(ntp_features::kIframeOneGoogleBar));
 }
 
 ChromeWebUIControllerFactory::ChromeWebUIControllerFactory() = default;

diff --git a/chrome/browser/ui/webui/nearby_internals/nearby_internals_contact_handler.cc b/chrome/browser/ui/webui/nearby_internals/nearby_internals_contact_handler.cc
index 60fa19f5..2c67108a 100644
--- a/chrome/browser/ui/webui/nearby_internals/nearby_internals_contact_handler.cc
+++ b/chrome/browser/ui/webui/nearby_internals/nearby_internals_contact_handler.cc

@@ -35,37 +35,45 @@
 const char kContactMessageContactsRemovedFromAllowedListKey[] =
     "contactsRemovedFromAllowlist";
 const char kContactMessageAllowedIdsKey[] = "allowedIds";
-const char kContactMessageContactsPassedKey[] = "contactsPassed";
 const char kContactMessageContactRecordKey[] = "contactRecords";
 
 // Converts Contact to a raw dictionary value used as a JSON argument to
 // JavaScript functions.
+// TODO(nohle): We should probably break up this dictionary into smaller
+// dictionaries corresponding to each contact-manager observer functions. This
+// will require changes at the javascript layer as well.
 base::Value ContactMessageToDictionary(
-    bool contacts_list_changed,
-    bool contacts_added_to_allowlist,
-    bool contacts_removed_from_allowlist,
-    const std::set<std::string>& allowed_contact_ids,
+    base::Optional<bool> did_contacts_change_since_last_upload,
+    base::Optional<bool> were_contacts_added_to_allowlist,
+    base::Optional<bool> were_contacts_removed_from_allowlist,
+    const base::Optional<std::set<std::string>>& allowed_contact_ids,
     const base::Optional<std::vector<nearbyshare::proto::ContactRecord>>&
         contacts) {
   base::Value dictionary(base::Value::Type::DICTIONARY);
 
   dictionary.SetKey(kContactMessageTimeKey, GetJavascriptTimestamp());
-  dictionary.SetBoolKey(kContactMessageContactListChangedKey,
-                        contacts_list_changed);
-  dictionary.SetBoolKey(kContactMessageContactsAddedToAllowedListKey,
-                        contacts_added_to_allowlist);
-  dictionary.SetBoolKey(kContactMessageContactsRemovedFromAllowedListKey,
-                        contacts_removed_from_allowlist);
-
-  base::Value::ListStorage allowed_ids_list;
-  allowed_ids_list.reserve(allowed_contact_ids.size());
-  for (const auto& contact_id : allowed_contact_ids)
-    allowed_ids_list.push_back(base::Value(contact_id));
-
-  dictionary.SetStringKey(kContactMessageAllowedIdsKey,
-                          FormatAsJSON(base::Value(std::move(allowed_ids_list))));
-
-  dictionary.SetBoolKey(kContactMessageContactsPassedKey, contacts.has_value());
+  if (did_contacts_change_since_last_upload.has_value()) {
+    dictionary.SetBoolKey(kContactMessageContactListChangedKey,
+                          *did_contacts_change_since_last_upload);
+  }
+  if (were_contacts_added_to_allowlist.has_value()) {
+    dictionary.SetBoolKey(kContactMessageContactsAddedToAllowedListKey,
+                          *were_contacts_added_to_allowlist);
+  }
+  if (were_contacts_removed_from_allowlist.has_value()) {
+    dictionary.SetBoolKey(kContactMessageContactsRemovedFromAllowedListKey,
+                          *were_contacts_removed_from_allowlist);
+  }
+  if (allowed_contact_ids) {
+    base::Value::ListStorage allowed_ids_list;
+    allowed_ids_list.reserve(allowed_contact_ids->size());
+    for (const auto& contact_id : *allowed_contact_ids) {
+      allowed_ids_list.push_back(base::Value(contact_id));
+    }
+    dictionary.SetStringKey(
+        kContactMessageAllowedIdsKey,
+        FormatAsJSON(base::Value(std::move(allowed_ids_list))));
+  }
   if (contacts) {
     base::Value::ListStorage contact_list;
     contact_list.reserve(contacts->size());
@@ -131,16 +139,36 @@
   }
 }
 
-void NearbyInternalsContactHandler::OnContactsUpdated(
-    bool contacts_list_changed,
-    bool contacts_added_to_allowlist,
-    bool contacts_removed_from_allowlist,
+void NearbyInternalsContactHandler::OnAllowlistChanged(
+    bool were_contacts_added_to_allowlist,
+    bool were_contacts_removed_from_allowlist) {
+  FireWebUIListener(
+      "contacts-updated",
+      ContactMessageToDictionary(
+          /*did_contacts_change_since_last_upload=*/base::nullopt,
+          were_contacts_added_to_allowlist,
+          were_contacts_removed_from_allowlist,
+          /*allowed_contact_ids=*/base::nullopt, /*contacts=*/base::nullopt));
+}
+
+void NearbyInternalsContactHandler::OnContactsDownloaded(
     const std::set<std::string>& allowed_contact_ids,
-    const base::Optional<std::vector<nearbyshare::proto::ContactRecord>>&
-        contacts) {
+    const std::vector<nearbyshare::proto::ContactRecord>& contacts) {
   FireWebUIListener("contacts-updated",
-                    ContactMessageToDictionary(contacts_list_changed,
-                                               contacts_added_to_allowlist,
-                                               contacts_removed_from_allowlist,
-                                               allowed_contact_ids, contacts));
+                    ContactMessageToDictionary(
+                        /*did_contacts_change_since_last_upload=*/base::nullopt,
+                        /*were_contacts_added_to_allowlist=*/base::nullopt,
+                        /*were_contacts_removed_from_allowlist=*/base::nullopt,
+                        allowed_contact_ids, contacts));
+}
+
+void NearbyInternalsContactHandler::OnContactsUploaded(
+    bool did_contacts_change_since_last_upload) {
+  FireWebUIListener(
+      "contacts-updated",
+      ContactMessageToDictionary(
+          did_contacts_change_since_last_upload,
+          /*were_contacts_added_to_allowlist=*/base::nullopt,
+          /*were_contacts_removed_from_allowlist=*/base::nullopt,
+          /*allowed_contact_ids=*/base::nullopt, /*contacts=*/base::nullopt));
 }

diff --git a/chrome/browser/ui/webui/nearby_internals/nearby_internals_contact_handler.h b/chrome/browser/ui/webui/nearby_internals/nearby_internals_contact_handler.h
index dc0e0a7d..3a636fa 100644
--- a/chrome/browser/ui/webui/nearby_internals/nearby_internals_contact_handler.h
+++ b/chrome/browser/ui/webui/nearby_internals/nearby_internals_contact_handler.h

@@ -46,13 +46,12 @@
   void InitializeContents(const base::ListValue* args);
 
   // NearbyShareContactManager::Observer:
-  void OnContactsUpdated(
-      bool contacts_list_changed,
-      bool contacts_added_to_allowlist,
-      bool contacts_removed_from_allowlist,
+  void OnAllowlistChanged(bool were_contacts_added_to_allowlist,
+                          bool were_contacts_removed_from_allowlist) override;
+  void OnContactsDownloaded(
       const std::set<std::string>& allowed_contact_ids,
-      const base::Optional<std::vector<nearbyshare::proto::ContactRecord>>&
-          contacts) override;
+      const std::vector<nearbyshare::proto::ContactRecord>& contacts) override;
+  void OnContactsUploaded(bool did_contacts_change_since_last_upload) override;
 
   // Message handler callback that requests a contacts download from the contact
   // manager.

diff --git a/chrome/browser/ui/webui/print_preview/local_printer_handler_default.cc b/chrome/browser/ui/webui/print_preview/local_printer_handler_default.cc
index d94ff5d..bf325ec 100644
--- a/chrome/browser/ui/webui/print_preview/local_printer_handler_default.cc
+++ b/chrome/browser/ui/webui/print_preview/local_printer_handler_default.cc

@@ -23,7 +23,6 @@
 
 #if defined(OS_MAC)
 #include "components/printing/browser/printer_capabilities_mac.h"
-#include "printing/printing_features.h"
 #endif
 
 #if defined(OS_WIN)
@@ -80,8 +79,7 @@
     const std::string& locale) {
   PrinterSemanticCapsAndDefaults::Papers user_defined_papers;
 #if defined(OS_MAC)
-  if (base::FeatureList::IsEnabled(features::kEnableCustomMacPaperSizes))
-    user_defined_papers = GetMacCustomPaperSizes();
+  user_defined_papers = GetMacCustomPaperSizes();
 #endif
 
 #if defined(OS_WIN)

diff --git a/chrome/browser/ui/webui/print_preview/pdf_printer_handler.cc b/chrome/browser/ui/webui/print_preview/pdf_printer_handler.cc
index bb362bb..c48314e 100644
--- a/chrome/browser/ui/webui/print_preview/pdf_printer_handler.cc
+++ b/chrome/browser/ui/webui/print_preview/pdf_printer_handler.cc

@@ -47,7 +47,6 @@
 
 #if defined(OS_MAC)
 #include "components/printing/browser/printer_capabilities_mac.h"
-#include "printing/printing_features.h"
 #endif
 
 #if defined(OS_CHROMEOS)
@@ -203,21 +202,18 @@
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
 #if defined(OS_MAC)
-  if (base::FeatureList::IsEnabled(features::kEnableCustomMacPaperSizes)) {
-    // Read the Mac custom paper sizes on a separate thread.
-    // USER_VISIBLE because the result is displayed in the print preview dialog.
-    base::ThreadPool::PostTaskAndReplyWithResult(
-        FROM_HERE, {base::MayBlock(), base::TaskPriority::USER_VISIBLE},
-        base::BindOnce(&GetMacCustomPaperSizes),
-        base::BindOnce(&ConstructCapabilitiesAndCompleteCallback,
-                       destination_id, std::move(callback)));
-    return;
-  }
-#endif
-
+  // Read the Mac custom paper sizes on a separate thread.
+  // USER_VISIBLE because the result is displayed in the print preview dialog.
+  base::ThreadPool::PostTaskAndReplyWithResult(
+      FROM_HERE, {base::MayBlock(), base::TaskPriority::USER_VISIBLE},
+      base::BindOnce(&GetMacCustomPaperSizes),
+      base::BindOnce(&ConstructCapabilitiesAndCompleteCallback, destination_id,
+                     std::move(callback)));
+#else
   ConstructCapabilitiesAndCompleteCallback(
       destination_id, std::move(callback),
       PrinterSemanticCapsAndDefaults::Papers());
+#endif
 }
 
 void PdfPrinterHandler::StartPrint(

diff --git a/chrome/browser/ui/webui/print_preview/pdf_printer_handler_unittest.cc b/chrome/browser/ui/webui/print_preview/pdf_printer_handler_unittest.cc
index 121a103..23cc471 100644
--- a/chrome/browser/ui/webui/print_preview/pdf_printer_handler_unittest.cc
+++ b/chrome/browser/ui/webui/print_preview/pdf_printer_handler_unittest.cc

@@ -17,10 +17,8 @@
 #include "url/gurl.h"
 
 #if defined(OS_MAC)
-#include "base/test/scoped_feature_list.h"
 #include "components/printing/browser/printer_capabilities_mac.h"
 #include "printing/backend/print_backend.h"
-#include "printing/printing_features.h"
 #include "ui/gfx/geometry/size.h"
 #endif
 
@@ -275,10 +273,6 @@
 #if defined(OS_MAC)
 TEST_F(PdfPrinterHandlerGetCapabilityTest,
        GetMacCustomPaperSizesInCapabilities) {
-  base::test::ScopedFeatureList local_feature;
-  local_feature.InitAndEnableFeature(
-      printing::features::kEnableCustomMacPaperSizes);
-
   constexpr char kPaperOptionPath[] = "capabilities.printer.media_size.option";
   static const PrinterSemanticCapsAndDefaults::Papers kTestPapers = {
       {"printer1", "", gfx::Size(101600, 127000)},

diff --git a/chrome/browser/ui/webui/settings/chromeos/personalization_section.cc b/chrome/browser/ui/webui/settings/chromeos/personalization_section.cc
index 9a12265..be7d475 100644
--- a/chrome/browser/ui/webui/settings/chromeos/personalization_section.cc
+++ b/chrome/browser/ui/webui/settings/chromeos/personalization_section.cc

@@ -53,8 +53,8 @@
        mojom::kChangePictureSubpagePath,
        mojom::SearchResultIcon::kAvatar,
        mojom::SearchResultDefaultRank::kMedium,
-       mojom::SearchResultType::kSubpage,
-       {.subpage = mojom::Subpage::kChangePicture},
+       mojom::SearchResultType::kSetting,
+       {.setting = mojom::Setting::kChangeDeviceAccountImage},
        {IDS_OS_SETTINGS_TAG_CHANGE_DEVICE_ACCOUNT_IMAGE_ALT1,
         IDS_OS_SETTINGS_TAG_CHANGE_DEVICE_ACCOUNT_IMAGE_ALT2,
         IDS_OS_SETTINGS_TAG_CHANGE_DEVICE_ACCOUNT_IMAGE_ALT3,

diff --git a/chrome/common/chrome_features.cc b/chrome/common/chrome_features.cc
index 3d88bc5..e1108d6 100644
--- a/chrome/common/chrome_features.cc
+++ b/chrome/common/chrome_features.cc

@@ -748,12 +748,6 @@
 const base::Feature kTeamfoodFlags{"TeamfoodFlags",
                                    base::FEATURE_DISABLED_BY_DEFAULT};
 
-#if defined(OS_CHROMEOS)
-// Use the Terminal System App legacy settings page.
-const base::Feature kTerminalSystemAppLegacySettings{
-    "TerminalSystemAppLegacySettings", base::FEATURE_DISABLED_BY_DEFAULT};
-#endif
-
 #if defined(OS_WIN)
 // Enables the blocking of third-party modules. This feature requires Windows 8
 // or higher because it depends on the ProcessExtensionPointDisablePolicy

diff --git a/chrome/common/chrome_features.h b/chrome/common/chrome_features.h
index 85f3f50..b4d96a7 100644
--- a/chrome/common/chrome_features.h
+++ b/chrome/common/chrome_features.h

@@ -495,11 +495,6 @@
 
 COMPONENT_EXPORT(CHROME_FEATURES) extern const base::Feature kTeamfoodFlags;
 
-#if defined(OS_CHROMEOS)
-COMPONENT_EXPORT(CHROME_FEATURES)
-extern const base::Feature kTerminalSystemAppLegacySettings;
-#endif
-
 #if defined(OS_WIN)
 // Only has an effect in branded builds.
 COMPONENT_EXPORT(CHROME_FEATURES)

diff --git a/chrome/services/sharing/nearby/platform_v2/bluetooth_classic_medium.cc b/chrome/services/sharing/nearby/platform_v2/bluetooth_classic_medium.cc
index 5fd627c..368aa73 100644
--- a/chrome/services/sharing/nearby/platform_v2/bluetooth_classic_medium.cc
+++ b/chrome/services/sharing/nearby/platform_v2/bluetooth_classic_medium.cc

@@ -20,7 +20,7 @@
 
 bool BluetoothClassicMedium::StartDiscovery(
     DiscoveryCallback discovery_callback) {
-  if (adapter_client_.is_bound() && discovery_callback_ &&
+  if (adapter_observer_.is_bound() && discovery_callback_ &&
       discovery_session_.is_bound()) {
     return true;
   }
@@ -29,9 +29,9 @@
   discovered_bluetooth_devices_map_.clear();
 
   bool success =
-      adapter_->SetClient(adapter_client_.BindNewPipeAndPassRemote());
+      adapter_->AddObserver(adapter_observer_.BindNewPipeAndPassRemote());
   if (!success) {
-    adapter_client_.reset();
+    adapter_observer_.reset();
     return false;
   }
 
@@ -39,7 +39,7 @@
   success = adapter_->StartDiscoverySession(&discovery_session);
 
   if (!success || !discovery_session.is_valid()) {
-    adapter_client_.reset();
+    adapter_observer_.reset();
     return false;
   }
 
@@ -63,7 +63,7 @@
     stop_discovery_success = stop_discovery_success && message_success;
   }
 
-  adapter_client_.reset();
+  adapter_observer_.reset();
   discovery_callback_.reset();
   discovery_session_.reset();
 
@@ -142,7 +142,7 @@
 
 void BluetoothClassicMedium::DeviceAdded(
     bluetooth::mojom::DeviceInfoPtr device) {
-  if (!adapter_client_.is_bound() || !discovery_callback_ ||
+  if (!adapter_observer_.is_bound() || !discovery_callback_ ||
       !discovery_session_.is_bound()) {
     return;
   }
@@ -166,7 +166,7 @@
 
 void BluetoothClassicMedium::DeviceRemoved(
     bluetooth::mojom::DeviceInfoPtr device) {
-  if (!adapter_client_.is_bound() || !discovery_callback_ ||
+  if (!adapter_observer_.is_bound() || !discovery_callback_ ||
       !discovery_session_.is_bound()) {
     return;
   }

diff --git a/chrome/services/sharing/nearby/platform_v2/bluetooth_classic_medium.h b/chrome/services/sharing/nearby/platform_v2/bluetooth_classic_medium.h
index 0c762c3..b23be02 100644
--- a/chrome/services/sharing/nearby/platform_v2/bluetooth_classic_medium.h
+++ b/chrome/services/sharing/nearby/platform_v2/bluetooth_classic_medium.h

@@ -24,7 +24,7 @@
 // implementation consumes the synchronous signatures of
 // bluetooth::mojom::Adapter methods.
 class BluetoothClassicMedium : public api::BluetoothClassicMedium,
-                               public bluetooth::mojom::AdapterClient {
+                               public bluetooth::mojom::AdapterObserver {
  public:
   explicit BluetoothClassicMedium(bluetooth::mojom::Adapter* adapter);
   ~BluetoothClassicMedium() override;
@@ -43,7 +43,7 @@
       const std::string& service_uuid) override;
 
  private:
-  // bluetooth::mojom::AdapterClient:
+  // bluetooth::mojom::AdapterObserver:
   void PresentChanged(bool present) override;
   void PoweredChanged(bool powered) override;
   void DiscoverableChanged(bool discoverable) override;
@@ -56,9 +56,9 @@
   // will always outlive this object.
   bluetooth::mojom::Adapter* adapter_ = nullptr;
 
-  // |adapter_client_| is only set and bound during active discovery so that
+  // |adapter_observer_| is only set and bound during active discovery so that
   // events we don't care about outside of discovery don't pile up.
-  mojo::Receiver<bluetooth::mojom::AdapterClient> adapter_client_{this};
+  mojo::Receiver<bluetooth::mojom::AdapterObserver> adapter_observer_{this};
 
   // These properties are only set while discovery is active.
   base::Optional<DiscoveryCallback> discovery_callback_;

diff --git a/chrome/services/sharing/nearby/test_support/fake_adapter.cc b/chrome/services/sharing/nearby/test_support/fake_adapter.cc
index e8d7e61a..d91987d 100644
--- a/chrome/services/sharing/nearby/test_support/fake_adapter.cc
+++ b/chrome/services/sharing/nearby/test_support/fake_adapter.cc

@@ -6,7 +6,6 @@
 
 #include <memory>
 
-#include "mojo/public/cpp/bindings/pending_remote.h"
 #include "mojo/public/cpp/bindings/self_owned_receiver.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -81,9 +80,10 @@
   std::move(callback).Run(std::move(adapter_info));
 }
 
-void FakeAdapter::SetClient(::mojo::PendingRemote<mojom::AdapterClient> client,
-                            SetClientCallback callback) {
-  client_.Bind(std::move(client));
+void FakeAdapter::AddObserver(
+    mojo::PendingRemote<mojom::AdapterObserver> observer,
+    AddObserverCallback callback) {
+  observers_.Add(std::move(observer));
   std::move(callback).Run();
 }
 
@@ -190,15 +190,18 @@
 }
 
 void FakeAdapter::NotifyDeviceAdded(mojom::DeviceInfoPtr device_info) {
-  client_->DeviceAdded(std::move(device_info));
+  for (auto& observer : observers_)
+    observer->DeviceAdded(device_info->Clone());
 }
 
 void FakeAdapter::NotifyDeviceChanged(mojom::DeviceInfoPtr device_info) {
-  client_->DeviceChanged(std::move(device_info));
+  for (auto& observer : observers_)
+    observer->DeviceChanged(device_info->Clone());
 }
 
 void FakeAdapter::NotifyDeviceRemoved(mojom::DeviceInfoPtr device_info) {
-  client_->DeviceRemoved(std::move(device_info));
+  for (auto& observer : observers_)
+    observer->DeviceRemoved(device_info->Clone());
 }
 
 void FakeAdapter::AllowConnectionForAddressAndUuidPair(

diff --git a/chrome/services/sharing/nearby/test_support/fake_adapter.h b/chrome/services/sharing/nearby/test_support/fake_adapter.h
index 0b041fef..6259906 100644
--- a/chrome/services/sharing/nearby/test_support/fake_adapter.h
+++ b/chrome/services/sharing/nearby/test_support/fake_adapter.h

@@ -7,6 +7,7 @@
 
 #include "device/bluetooth/public/cpp/bluetooth_uuid.h"
 #include "device/bluetooth/public/mojom/adapter.mojom.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
 #include "mojo/public/cpp/bindings/receiver.h"
 #include "mojo/public/cpp/bindings/remote_set.h"
 
@@ -24,8 +25,8 @@
                        ConnectToDeviceCallback callback) override;
   void GetDevices(GetDevicesCallback callback) override;
   void GetInfo(GetInfoCallback callback) override;
-  void SetClient(::mojo::PendingRemote<mojom::AdapterClient> client,
-                 SetClientCallback callback) override;
+  void AddObserver(mojo::PendingRemote<mojom::AdapterObserver> observer,
+                   AddObserverCallback callback) override;
   void SetDiscoverable(bool discoverable,
                        SetDiscoverableCallback callback) override;
   void SetName(const std::string& name, SetNameCallback callback) override;
@@ -69,7 +70,7 @@
   std::set<std::pair<std::string, device::BluetoothUUID>>
       allowed_connections_for_service_name_and_uuid_pair_;
 
-  mojo::Remote<mojom::AdapterClient> client_;
+  mojo::RemoteSet<mojom::AdapterObserver> observers_;
 };
 
 }  // namespace bluetooth

diff --git a/chrome/test/BUILD.gn b/chrome/test/BUILD.gn
index 62b1bfc..070511a 100644
--- a/chrome/test/BUILD.gn
+++ b/chrome/test/BUILD.gn

@@ -2608,6 +2608,7 @@
         "../browser/ui/views/frame/immersive_mode_controller_ash_browsertest.cc",
         "../browser/ui/views/frame/system_menu_model_builder_browsertest_chromeos.cc",
         "../browser/ui/views/frame/top_controls_slide_controller_chromeos_browsertest.cc",
+        "../browser/ui/views/intent_picker_bubble_view_browsertest_chromeos.cc",
         "../browser/ui/views/plugin_vm/plugin_vm_installer_view_browsertest.cc",
         "../browser/ui/views/supervised_user/extension_install_blocked_by_parent_dialog_view_browsertest.cc",
         "../browser/ui/views/supervised_user/parent_permission_dialog_view_browsertest.cc",

diff --git a/chrome/test/data/webui/bluetooth_internals_browsertest.js b/chrome/test/data/webui/bluetooth_internals_browsertest.js
index 3efd8e5..895a9961 100644
--- a/chrome/test/data/webui/bluetooth_internals_browsertest.js
+++ b/chrome/test/data/webui/bluetooth_internals_browsertest.js

@@ -87,7 +87,7 @@
         super([
           'getInfo',
           'getDevices',
-          'setClient',
+          'addObserver',
         ]);
 
         this.receiver = new bluetooth.mojom.AdapterReceiver(this);
@@ -122,8 +122,8 @@
         return {devices: this.devices_};
       }
 
-      async setClient(client) {
-        this.methodCalled('setClient', client);
+      async addObserver(observer) {
+        this.methodCalled('addObserver', observer);
       }
 
       async setDiscoverable() {
@@ -366,7 +366,7 @@
         internalsHandler.whenCalled('getAdapter'),
         internalsHandler.adapter.whenCalled('getInfo'),
         internalsHandler.adapter.whenCalled('getDevices'),
-        internalsHandler.adapter.whenCalled('setClient')
+        internalsHandler.adapter.whenCalled('addObserver')
       ]);
     });
 

diff --git a/chromecast/base/cast_features.cc b/chromecast/base/cast_features.cc
index b5e9667..106a8057 100644
--- a/chromecast/base/cast_features.cc
+++ b/chromecast/base/cast_features.cc

@@ -158,10 +158,6 @@
 const base::Feature kEnableSideGesturePassThrough{
     "enable_side_gesture_pass_through", base::FEATURE_DISABLED_BY_DEFAULT};
 
-// Lowers frame rate for headless
-const base::Feature kReduceHeadlessFrameRate{"reduce_headless_frame_rate",
-                                             base::FEATURE_DISABLED_BY_DEFAULT};
-
 // Uses AudioManagerAndroid, instead of CastAudioManagerAndroid. This will
 // disable lots of Cast features, so it should only be used for development and
 // testing.
@@ -178,7 +174,6 @@
     &kEnableGeneralAudienceBrowsing,
     &kUseQueryableDataBackend,
     &kEnableSideGesturePassThrough,
-    &kReduceHeadlessFrameRate,
     &kEnableChromeAudioManagerAndroid,
 };
 

diff --git a/chromecast/base/cast_features.h b/chromecast/base/cast_features.h
index 152d7b2..cabb320 100644
--- a/chromecast/base/cast_features.h
+++ b/chromecast/base/cast_features.h

@@ -31,7 +31,6 @@
 extern const base::Feature kEnableGeneralAudienceBrowsing;
 extern const base::Feature kUseQueryableDataBackend;
 extern const base::Feature kEnableSideGesturePassThrough;
-extern const base::Feature kReduceHeadlessFrameRate;
 extern const base::Feature kEnableChromeAudioManagerAndroid;
 
 // Get an iterable list of all of the cast features for checking all features as

diff --git a/chromecast/graphics/cast_window_manager_aura.cc b/chromecast/graphics/cast_window_manager_aura.cc
index 069f7b7..91f2fc4 100644
--- a/chromecast/graphics/cast_window_manager_aura.cc
+++ b/chromecast/graphics/cast_window_manager_aura.cc

@@ -4,7 +4,6 @@
 
 #include "chromecast/graphics/cast_window_manager_aura.h"
 
-#include "base/feature_list.h"
 #include "base/memory/ptr_util.h"
 #include "build/build_config.h"
 #include "chromecast/base/cast_features.h"
@@ -236,11 +235,8 @@
   rounded_window_corners_ = RoundedWindowCorners::Create(this);
 
 #if BUILDFLAG(IS_CAST_AUDIO_ONLY)
-  if (base::FeatureList::IsEnabled(kReduceHeadlessFrameRate)) {
-    ui::Compositor* compositor = window_tree_host_->compositor();
-    compositor->SetDisplayVSyncParameters(
-        base::TimeTicks(), base::TimeDelta::FromMilliseconds(250));
-  }
+  window_tree_host_->compositor()->SetDisplayVSyncParameters(
+      base::TimeTicks(), base::TimeDelta::FromMilliseconds(250));
 #endif
 }
 

diff --git a/chromecast/public/reboot_shlib.h b/chromecast/public/reboot_shlib.h
index 4c30b96..574015f 100644
--- a/chromecast/public/reboot_shlib.h
+++ b/chromecast/public/reboot_shlib.h

@@ -75,6 +75,10 @@
 
     // A reboot is triggered due to successive OOM events.
     REPEATED_OOM = 13,
+
+    // A reboot is triggered when the utility process is found to be in
+    // crash loop.
+    UTILITY_PROCESS_CRASH = 14,
   };
 
   // Initializes any platform-specific reboot systems.

diff --git a/chromeos/components/multidevice/fake_secure_message_delegate.cc b/chromeos/components/multidevice/fake_secure_message_delegate.cc
index 110426f..d8fabc5b 100644
--- a/chromeos/components/multidevice/fake_secure_message_delegate.cc
+++ b/chromeos/components/multidevice/fake_secure_message_delegate.cc

@@ -98,7 +98,7 @@
 FakeSecureMessageDelegate::~FakeSecureMessageDelegate() = default;
 
 void FakeSecureMessageDelegate::GenerateKeyPair(
-    const GenerateKeyPairCallback& callback) {
+    GenerateKeyPairCallback callback) {
   std::string public_key = next_public_key_;
 
   // The private key is simply the public key prepended with "private_".
@@ -106,12 +106,12 @@
 
   next_public_key_ = std::string(kKeyPrefix) + base::MD5String(public_key);
 
-  callback.Run(public_key, private_key);
+  std::move(callback).Run(public_key, private_key);
 }
 
 void FakeSecureMessageDelegate::DeriveKey(const std::string& private_key,
                                           const std::string& public_key,
-                                          const DeriveKeyCallback& callback) {
+                                          DeriveKeyCallback callback) {
   // To ensure that the same symmetric key is derived for DeriveKey(private1,
   // public2) and DeriveKey(private2, public1), we remove the prefix from the
   // private key so it is equal to its corresponding public key.
@@ -125,14 +125,14 @@
   keys.push_back(normalized_private_key);
   keys.push_back(public_key);
   std::sort(keys.begin(), keys.end());
-  callback.Run(base::MD5String(keys[0] + "|" + keys[1]));
+  std::move(callback).Run(base::MD5String(keys[0] + "|" + keys[1]));
 }
 
 void FakeSecureMessageDelegate::CreateSecureMessage(
     const std::string& payload,
     const std::string& key,
     const CreateOptions& create_options,
-    const CreateSecureMessageCallback& callback) {
+    CreateSecureMessageCallback callback) {
   securemessage::Header header;
   header.set_signature_scheme(create_options.signature_scheme);
   header.set_encryption_scheme(create_options.encryption_scheme);
@@ -157,25 +157,25 @@
 
   std::string serialized_secure_message;
   secure_message.SerializeToString(&serialized_secure_message);
-  callback.Run(serialized_secure_message);
+  std::move(callback).Run(serialized_secure_message);
 }
 
 void FakeSecureMessageDelegate::UnwrapSecureMessage(
     const std::string& serialized_message,
     const std::string& key,
     const UnwrapOptions& unwrap_options,
-    const UnwrapSecureMessageCallback& callback) {
+    UnwrapSecureMessageCallback callback) {
   securemessage::SecureMessage secure_message;
   if (!secure_message.ParseFromString(serialized_message)) {
     LOG(ERROR) << "Failed to parse SecureMessage.";
-    callback.Run(false, std::string(), securemessage::Header());
+    std::move(callback).Run(false, std::string(), securemessage::Header());
     return;
   }
 
   securemessage::HeaderAndBody header_and_body;
   if (!header_and_body.ParseFromString(secure_message.header_and_body())) {
     LOG(ERROR) << "Failed to parse secure message HeaderAndBody.";
-    callback.Run(false, std::string(), securemessage::Header());
+    std::move(callback).Run(false, std::string(), securemessage::Header());
     return;
   }
 
@@ -187,9 +187,9 @@
                          unwrap_options.associated_data, key,
                          unwrap_options.signature_scheme);
   if (verified) {
-    callback.Run(true, payload, header);
+    std::move(callback).Run(true, payload, header);
   } else {
-    callback.Run(false, std::string(), securemessage::Header());
+    std::move(callback).Run(false, std::string(), securemessage::Header());
   }
 }
 

diff --git a/chromeos/components/multidevice/fake_secure_message_delegate.h b/chromeos/components/multidevice/fake_secure_message_delegate.h
index 5430dd3..8bf3d17f 100644
--- a/chromeos/components/multidevice/fake_secure_message_delegate.h
+++ b/chromeos/components/multidevice/fake_secure_message_delegate.h

@@ -24,20 +24,18 @@
   ~FakeSecureMessageDelegate() override;
 
   // SecureMessageDelegate:
-  void GenerateKeyPair(const GenerateKeyPairCallback& callback) override;
+  void GenerateKeyPair(GenerateKeyPairCallback callback) override;
   void DeriveKey(const std::string& private_key,
                  const std::string& public_key,
-                 const DeriveKeyCallback& callback) override;
-  void CreateSecureMessage(
-      const std::string& payload,
-      const std::string& key,
-      const CreateOptions& create_options,
-      const CreateSecureMessageCallback& callback) override;
-  void UnwrapSecureMessage(
-      const std::string& serialized_message,
-      const std::string& key,
-      const UnwrapOptions& unwrap_options,
-      const UnwrapSecureMessageCallback& callback) override;
+                 DeriveKeyCallback callback) override;
+  void CreateSecureMessage(const std::string& payload,
+                           const std::string& key,
+                           const CreateOptions& create_options,
+                           CreateSecureMessageCallback callback) override;
+  void UnwrapSecureMessage(const std::string& serialized_message,
+                           const std::string& key,
+                           const UnwrapOptions& unwrap_options,
+                           UnwrapSecureMessageCallback callback) override;
 
   // Returns the corresponding private key for the given |public_key|.
   std::string GetPrivateKeyForPublicKey(const std::string& public_key);

diff --git a/chromeos/components/multidevice/fake_secure_message_delegate_unittest.cc b/chromeos/components/multidevice/fake_secure_message_delegate_unittest.cc
index ddbc8f7a1..4157a60 100644
--- a/chromeos/components/multidevice/fake_secure_message_delegate_unittest.cc
+++ b/chromeos/components/multidevice/fake_secure_message_delegate_unittest.cc

@@ -104,12 +104,12 @@
 TEST_F(CryptAuthFakeSecureMessageDelegateTest, GenerateKeyPair) {
   std::string public_key1, private_key1;
   delegate_.GenerateKeyPair(
-      base::Bind(&SaveKeyPair, &public_key1, &private_key1));
+      base::BindOnce(&SaveKeyPair, &public_key1, &private_key1));
   EXPECT_NE(private_key1, public_key1);
 
   std::string public_key2, private_key2;
   delegate_.GenerateKeyPair(
-      base::Bind(&SaveKeyPair, &public_key2, &private_key2));
+      base::BindOnce(&SaveKeyPair, &public_key2, &private_key2));
   EXPECT_NE(private_key2, public_key2);
 
   EXPECT_NE(public_key1, public_key2);
@@ -118,7 +118,7 @@
   delegate_.set_next_public_key(kTestPublicKey);
   std::string public_key3, private_key3;
   delegate_.GenerateKeyPair(
-      base::Bind(&SaveKeyPair, &public_key3, &private_key3));
+      base::BindOnce(&SaveKeyPair, &public_key3, &private_key3));
   EXPECT_EQ(kTestPublicKey, public_key3);
   EXPECT_NE(private_key3, public_key3);
 
@@ -130,18 +130,18 @@
   delegate_.set_next_public_key("key_pair_1");
   std::string public_key1, private_key1;
   delegate_.GenerateKeyPair(
-      base::Bind(&SaveKeyPair, &public_key1, &private_key1));
+      base::BindOnce(&SaveKeyPair, &public_key1, &private_key1));
 
   delegate_.set_next_public_key("key_pair_2");
   std::string public_key2, private_key2;
   delegate_.GenerateKeyPair(
-      base::Bind(&SaveKeyPair, &public_key2, &private_key2));
+      base::BindOnce(&SaveKeyPair, &public_key2, &private_key2));
 
   std::string symmetric_key1, symmetric_key2;
   delegate_.DeriveKey(private_key1, public_key2,
-                      base::Bind(&SaveString, &symmetric_key1));
+                      base::BindOnce(&SaveString, &symmetric_key1));
   delegate_.DeriveKey(private_key2, public_key1,
-                      base::Bind(&SaveString, &symmetric_key2));
+                      base::BindOnce(&SaveString, &symmetric_key2));
 
   EXPECT_EQ(symmetric_key1, symmetric_key2);
 }
@@ -152,8 +152,9 @@
   SecureMessageDelegate::CreateOptions create_options =
       GetCreateOptions(securemessage::AES_256_CBC, securemessage::HMAC_SHA256);
   std::string serialized_message;
-  delegate_.CreateSecureMessage(kPayload, kSymmetricKey, create_options,
-                                base::Bind(&SaveString, &serialized_message));
+  delegate_.CreateSecureMessage(
+      kPayload, kSymmetricKey, create_options,
+      base::BindOnce(&SaveString, &serialized_message));
 
   CheckSerializedSecureMessage(serialized_message, create_options);
 
@@ -164,7 +165,7 @@
   securemessage::Header header;
   delegate_.UnwrapSecureMessage(
       serialized_message, kSymmetricKey, unwrap_options,
-      base::Bind(&SaveUnwrapResults, &payload, &header));
+      base::BindOnce(&SaveUnwrapResults, &payload, &header));
 
   EXPECT_EQ(kPayload, payload);
 }
@@ -174,14 +175,15 @@
   delegate_.set_next_public_key(kTestPublicKey);
   std::string public_key, private_key;
   delegate_.GenerateKeyPair(
-      base::Bind(&SaveKeyPair, &public_key, &private_key));
+      base::BindOnce(&SaveKeyPair, &public_key, &private_key));
 
   // Create SecureMessage using asymmetric key.
   SecureMessageDelegate::CreateOptions create_options =
       GetCreateOptions(securemessage::NONE, securemessage::ECDSA_P256_SHA256);
   std::string serialized_message;
-  delegate_.CreateSecureMessage(kPayload, private_key, create_options,
-                                base::Bind(&SaveString, &serialized_message));
+  delegate_.CreateSecureMessage(
+      kPayload, private_key, create_options,
+      base::BindOnce(&SaveString, &serialized_message));
 
   CheckSerializedSecureMessage(serialized_message, create_options);
 
@@ -192,7 +194,7 @@
   securemessage::Header header;
   delegate_.UnwrapSecureMessage(
       serialized_message, public_key, unwrap_options,
-      base::Bind(&SaveUnwrapResults, &payload, &header));
+      base::BindOnce(&SaveUnwrapResults, &payload, &header));
 
   EXPECT_EQ(kPayload, payload);
 }
@@ -201,7 +203,7 @@
   delegate_.set_next_public_key(kTestPublicKey);
   std::string public_key, private_key;
   delegate_.GenerateKeyPair(
-      base::Bind(&SaveKeyPair, &public_key, &private_key));
+      base::BindOnce(&SaveKeyPair, &public_key, &private_key));
   EXPECT_EQ(kTestPublicKey, public_key);
   EXPECT_EQ(private_key, delegate_.GetPrivateKeyForPublicKey(kTestPublicKey));
 }

diff --git a/chromeos/components/multidevice/secure_message_delegate.h b/chromeos/components/multidevice/secure_message_delegate.h
index 2589e17..5c697180 100644
--- a/chromeos/components/multidevice/secure_message_delegate.h
+++ b/chromeos/components/multidevice/secure_message_delegate.h

@@ -59,45 +59,43 @@
   virtual ~SecureMessageDelegate();
 
   // Generates a new asymmetric key pair.
-  typedef base::Callback<void(const std::string& public_key,
-                              const std::string& private_key)>
+  typedef base::OnceCallback<void(const std::string& public_key,
+                                  const std::string& private_key)>
       GenerateKeyPairCallback;
-  virtual void GenerateKeyPair(const GenerateKeyPairCallback& callback) = 0;
+  virtual void GenerateKeyPair(GenerateKeyPairCallback callback) = 0;
 
   // Derives a symmetric key from our private key and the remote device's
   // public key.
-  typedef base::Callback<void(const std::string& derived_key)>
+  typedef base::OnceCallback<void(const std::string& derived_key)>
       DeriveKeyCallback;
   virtual void DeriveKey(const std::string& private_key,
                          const std::string& public_key,
-                         const DeriveKeyCallback& callback) = 0;
+                         DeriveKeyCallback callback) = 0;
 
   // Creates a new secure message with a |payload| given the |key| and
   // |create_options| specifying the cryptographic details.
   // |callback| will be invoked with the serialized SecureMessage upon success
   // or the empty string upon failure.
-  typedef base::Callback<void(const std::string& secure_message)>
+  typedef base::OnceCallback<void(const std::string& secure_message)>
       CreateSecureMessageCallback;
-  virtual void CreateSecureMessage(
-      const std::string& payload,
-      const std::string& key,
-      const CreateOptions& create_options,
-      const CreateSecureMessageCallback& callback) = 0;
+  virtual void CreateSecureMessage(const std::string& payload,
+                                   const std::string& key,
+                                   const CreateOptions& create_options,
+                                   CreateSecureMessageCallback callback) = 0;
 
   // Unwraps |secure_message| given the |key| and |unwrap_options| specifying
   // the cryptographic details.
   // |callback| will be invoked with true for the |verified| argument if the
   // message was verified and decrypted successfully. The |payload| and
   // |header| fields will be non-empty if the message was verified successfully.
-  typedef base::Callback<void(bool verified,
-                              const std::string& payload,
-                              const securemessage::Header& header)>
+  typedef base::OnceCallback<void(bool verified,
+                                  const std::string& payload,
+                                  const securemessage::Header& header)>
       UnwrapSecureMessageCallback;
-  virtual void UnwrapSecureMessage(
-      const std::string& serialized_message,
-      const std::string& key,
-      const UnwrapOptions& unwrap_options,
-      const UnwrapSecureMessageCallback& callback) = 0;
+  virtual void UnwrapSecureMessage(const std::string& serialized_message,
+                                   const std::string& key,
+                                   const UnwrapOptions& unwrap_options,
+                                   UnwrapSecureMessageCallback callback) = 0;
 };
 
 }  // namespace multidevice

diff --git a/chromeos/components/multidevice/secure_message_delegate_impl.cc b/chromeos/components/multidevice/secure_message_delegate_impl.cc
index 53d1675..338502a 100644
--- a/chromeos/components/multidevice/secure_message_delegate_impl.cc
+++ b/chromeos/components/multidevice/secure_message_delegate_impl.cc

@@ -52,23 +52,24 @@
 // Parses the serialized HeaderAndBody string returned by the DBus client, and
 // calls the corresponding SecureMessageDelegate unwrap callback.
 void HandleUnwrapResult(
-    const SecureMessageDelegate::UnwrapSecureMessageCallback& callback,
+    SecureMessageDelegate::UnwrapSecureMessageCallback callback,
     const std::string& unwrap_result) {
   securemessage::HeaderAndBody header_and_body;
   if (!header_and_body.ParseFromString(unwrap_result)) {
-    callback.Run(false, std::string(), securemessage::Header());
+    std::move(callback).Run(false, std::string(), securemessage::Header());
   } else {
-    callback.Run(true, header_and_body.body(), header_and_body.header());
+    std::move(callback).Run(true, header_and_body.body(),
+                            header_and_body.header());
   }
 }
 
 // The SecureMessageDelegate expects the keys in the reverse order returned by
 // the DBus client.
 void HandleKeyPairResult(
-    const SecureMessageDelegate::GenerateKeyPairCallback& callback,
+    SecureMessageDelegate::GenerateKeyPairCallback callback,
     const std::string& private_key,
     const std::string& public_key) {
-  callback.Run(public_key, private_key);
+  std::move(callback).Run(public_key, private_key);
 }
 
 }  // namespace
@@ -100,26 +101,27 @@
 SecureMessageDelegateImpl::~SecureMessageDelegateImpl() {}
 
 void SecureMessageDelegateImpl::GenerateKeyPair(
-    const GenerateKeyPairCallback& callback) {
+    GenerateKeyPairCallback callback) {
   dbus_client_->GenerateEcP256KeyPair(
-      base::BindOnce(HandleKeyPairResult, callback));
+      base::BindOnce(HandleKeyPairResult, std::move(callback)));
 }
 
 void SecureMessageDelegateImpl::DeriveKey(const std::string& private_key,
                                           const std::string& public_key,
-                                          const DeriveKeyCallback& callback) {
-  dbus_client_->PerformECDHKeyAgreement(private_key, public_key, callback);
+                                          DeriveKeyCallback callback) {
+  dbus_client_->PerformECDHKeyAgreement(private_key, public_key,
+                                        std::move(callback));
 }
 
 void SecureMessageDelegateImpl::CreateSecureMessage(
     const std::string& payload,
     const std::string& key,
     const CreateOptions& create_options,
-    const CreateSecureMessageCallback& callback) {
+    CreateSecureMessageCallback callback) {
   if (create_options.signature_scheme == securemessage::RSA2048_SHA256) {
     PA_LOG(ERROR) << "Unable to create message: RSA2048_SHA256 not supported "
                   << "by the ChromeOS daemon.";
-    callback.Run(std::string());
+    std::move(callback).Run(std::string());
     return;
   }
 
@@ -141,18 +143,18 @@
   options.encryption_type = EncSchemeToString(create_options.encryption_scheme);
   options.signature_type = SigSchemeToString(create_options.signature_scheme);
 
-  dbus_client_->CreateSecureMessage(payload, options, callback);
+  dbus_client_->CreateSecureMessage(payload, options, std::move(callback));
 }
 
 void SecureMessageDelegateImpl::UnwrapSecureMessage(
     const std::string& serialized_message,
     const std::string& key,
     const UnwrapOptions& unwrap_options,
-    const UnwrapSecureMessageCallback& callback) {
+    UnwrapSecureMessageCallback callback) {
   if (unwrap_options.signature_scheme == securemessage::RSA2048_SHA256) {
     PA_LOG(ERROR) << "Unable to unwrap message: RSA2048_SHA256 not supported "
                   << "by the ChromeOS daemon.";
-    callback.Run(false, std::string(), securemessage::Header());
+    std::move(callback).Run(false, std::string(), securemessage::Header());
     return;
   }
 
@@ -167,7 +169,7 @@
 
   dbus_client_->UnwrapSecureMessage(
       serialized_message, options,
-      base::BindOnce(&HandleUnwrapResult, callback));
+      base::BindOnce(&HandleUnwrapResult, std::move(callback)));
 }
 
 }  // namespace multidevice

diff --git a/chromeos/components/multidevice/secure_message_delegate_impl.h b/chromeos/components/multidevice/secure_message_delegate_impl.h
index 71fe7d5..73de08a 100644
--- a/chromeos/components/multidevice/secure_message_delegate_impl.h
+++ b/chromeos/components/multidevice/secure_message_delegate_impl.h

@@ -33,20 +33,18 @@
   ~SecureMessageDelegateImpl() override;
 
   // SecureMessageDelegate:
-  void GenerateKeyPair(const GenerateKeyPairCallback& callback) override;
+  void GenerateKeyPair(GenerateKeyPairCallback callback) override;
   void DeriveKey(const std::string& private_key,
                  const std::string& public_key,
-                 const DeriveKeyCallback& callback) override;
-  void CreateSecureMessage(
-      const std::string& payload,
-      const std::string& key,
-      const CreateOptions& create_options,
-      const CreateSecureMessageCallback& callback) override;
-  void UnwrapSecureMessage(
-      const std::string& serialized_message,
-      const std::string& key,
-      const UnwrapOptions& unwrap_options,
-      const UnwrapSecureMessageCallback& callback) override;
+                 DeriveKeyCallback callback) override;
+  void CreateSecureMessage(const std::string& payload,
+                           const std::string& key,
+                           const CreateOptions& create_options,
+                           CreateSecureMessageCallback callback) override;
+  void UnwrapSecureMessage(const std::string& serialized_message,
+                           const std::string& key,
+                           const UnwrapOptions& unwrap_options,
+                           UnwrapSecureMessageCallback callback) override;
 
  private:
   SecureMessageDelegateImpl();

diff --git a/chromeos/services/secure_channel/device_to_device_secure_context.cc b/chromeos/services/secure_channel/device_to_device_secure_context.cc
index 68ea5d3..89a55477 100644
--- a/chromeos/services/secure_channel/device_to_device_secure_context.cc
+++ b/chromeos/services/secure_channel/device_to_device_secure_context.cc

@@ -49,19 +49,19 @@
 DeviceToDeviceSecureContext::~DeviceToDeviceSecureContext() {}
 
 void DeviceToDeviceSecureContext::Decode(const std::string& encoded_message,
-                                         const MessageCallback& callback) {
+                                         MessageCallback callback) {
   multidevice::SecureMessageDelegate::UnwrapOptions unwrap_options;
   unwrap_options.encryption_scheme = securemessage::AES_256_CBC;
   unwrap_options.signature_scheme = securemessage::HMAC_SHA256;
 
   secure_message_delegate_->UnwrapSecureMessage(
       encoded_message, decryption_key_, unwrap_options,
-      base::Bind(&DeviceToDeviceSecureContext::HandleUnwrapResult,
-                 weak_ptr_factory_.GetWeakPtr(), callback));
+      base::BindOnce(&DeviceToDeviceSecureContext::HandleUnwrapResult,
+                     weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
 }
 
 void DeviceToDeviceSecureContext::Encode(const std::string& message,
-                                         const MessageCallback& callback) {
+                                         MessageCallback callback) {
   // Create a cryptauth::GcmMetadata field to put in the header.
   cryptauth::GcmMetadata gcm_metadata;
   gcm_metadata.set_type(cryptauth::DEVICE_TO_DEVICE_MESSAGE);
@@ -79,7 +79,7 @@
 
   secure_message_delegate_->CreateSecureMessage(
       device_to_device_message.SerializeAsString(), encryption_key_,
-      create_options, callback);
+      create_options, std::move(callback));
 }
 
 std::string DeviceToDeviceSecureContext::GetChannelBindingData() const {
@@ -92,7 +92,7 @@
 }
 
 void DeviceToDeviceSecureContext::HandleUnwrapResult(
-    const DeviceToDeviceSecureContext::MessageCallback& callback,
+    DeviceToDeviceSecureContext::MessageCallback callback,
     bool verified,
     const std::string& payload,
     const securemessage::Header& header) {
@@ -100,7 +100,7 @@
   securegcm::DeviceToDeviceMessage device_to_device_message;
   if (!verified || !device_to_device_message.ParseFromString(payload)) {
     PA_LOG(ERROR) << "Failed to unwrap secure message.";
-    callback.Run(std::string());
+    std::move(callback).Run(std::string());
     return;
   }
 
@@ -110,7 +110,7 @@
     PA_LOG(ERROR) << "Expected sequence_number="
                   << last_decode_sequence_number_ + 1 << ", but got "
                   << device_to_device_message.sequence_number();
-    callback.Run(std::string());
+    std::move(callback).Run(std::string());
     return;
   }
 
@@ -120,12 +120,12 @@
       gcm_metadata.type() != cryptauth::DEVICE_TO_DEVICE_MESSAGE ||
       gcm_metadata.version() != kGcmMetadataVersion) {
     PA_LOG(ERROR) << "Failed to validate cryptauth::GcmMetadata.";
-    callback.Run(std::string());
+    std::move(callback).Run(std::string());
     return;
   }
 
   last_decode_sequence_number_++;
-  callback.Run(device_to_device_message.message());
+  std::move(callback).Run(device_to_device_message.message());
 }
 
 }  // namespace secure_channel

diff --git a/chromeos/services/secure_channel/device_to_device_secure_context.h b/chromeos/services/secure_channel/device_to_device_secure_context.h
index 1bde09e4..648946a 100644
--- a/chromeos/services/secure_channel/device_to_device_secure_context.h
+++ b/chromeos/services/secure_channel/device_to_device_secure_context.h

@@ -38,9 +38,8 @@
 
   // SecureContext:
   void Decode(const std::string& encoded_message,
-              const MessageCallback& callback) override;
-  void Encode(const std::string& message,
-              const MessageCallback& callback) override;
+              MessageCallback callback) override;
+  void Encode(const std::string& message, MessageCallback callback) override;
   ProtocolVersion GetProtocolVersion() const override;
   std::string GetChannelBindingData() const override;
 
@@ -48,11 +47,10 @@
   // Callback for unwrapping a secure message. |callback| will be invoked with
   // the decrypted payload if the message is unwrapped successfully; otherwise
   // it will be invoked with an empty string.
-  void HandleUnwrapResult(
-      const DeviceToDeviceSecureContext::MessageCallback& callback,
-      bool verified,
-      const std::string& payload,
-      const securemessage::Header& header);
+  void HandleUnwrapResult(DeviceToDeviceSecureContext::MessageCallback callback,
+                          bool verified,
+                          const std::string& payload,
+                          const securemessage::Header& header);
 
   // Delegate for handling the creation and unwrapping of SecureMessages.
   std::unique_ptr<multidevice::SecureMessageDelegate> secure_message_delegate_;

diff --git a/chromeos/services/secure_channel/device_to_device_secure_context_unittest.cc b/chromeos/services/secure_channel/device_to_device_secure_context_unittest.cc
index a15d36b..8fde7421 100644
--- a/chromeos/services/secure_channel/device_to_device_secure_context_unittest.cc
+++ b/chromeos/services/secure_channel/device_to_device_secure_context_unittest.cc

@@ -71,7 +71,8 @@
 TEST_F(SecureChannelDeviceToDeviceSecureContextTest, CheckEncodedHeader) {
   std::string message = "encrypt this message";
   std::string encoded_message;
-  secure_context_.Encode(message, base::Bind(&SaveResult, &encoded_message));
+  secure_context_.Encode(message,
+                         base::BindOnce(&SaveResult, &encoded_message));
 
   securemessage::SecureMessage secure_message;
   ASSERT_TRUE(secure_message.ParseFromString(encoded_message));
@@ -90,7 +91,7 @@
   std::string encoded_message = "invalidly encoded message";
   std::string decoded_message = "not empty";
   secure_context_.Decode(encoded_message,
-                         base::Bind(&SaveResult, &decoded_message));
+                         base::BindOnce(&SaveResult, &decoded_message));
   EXPECT_TRUE(decoded_message.empty());
 }
 
@@ -111,12 +112,13 @@
   // Pass some messages between the two secure contexts.
   for (int i = 0; i < 3; ++i) {
     std::string encoded_message;
-    secure_context_.Encode(message, base::Bind(&SaveResult, &encoded_message));
+    secure_context_.Encode(message,
+                           base::BindOnce(&SaveResult, &encoded_message));
     EXPECT_NE(message, encoded_message);
 
     std::string decoded_message;
     secure_context2.Decode(encoded_message,
-                           base::Bind(&SaveResult, &decoded_message));
+                           base::BindOnce(&SaveResult, &decoded_message));
     EXPECT_EQ(message, decoded_message);
   }
 }
@@ -133,13 +135,14 @@
   std::string message = "encrypt this message";
   std::string encoded1;
   for (int i = 0; i < 3; ++i) {
-    secure_context_.Encode(message, base::Bind(&SaveResult, &encoded1));
+    secure_context_.Encode(message, base::BindOnce(&SaveResult, &encoded1));
   }
 
   // Second secure channel should not decode the message with an invalid
   // sequence number.
   std::string decoded_message = "not empty";
-  secure_context_.Decode(encoded1, base::Bind(&SaveResult, &decoded_message));
+  secure_context_.Decode(encoded1,
+                         base::BindOnce(&SaveResult, &decoded_message));
   EXPECT_TRUE(decoded_message.empty());
 }
 

diff --git a/chromeos/services/secure_channel/fake_secure_context.cc b/chromeos/services/secure_channel/fake_secure_context.cc
index 1882cb2..d34886f 100644
--- a/chromeos/services/secure_channel/fake_secure_context.cc
+++ b/chromeos/services/secure_channel/fake_secure_context.cc

@@ -34,20 +34,21 @@
 }
 
 void FakeSecureContext::Encode(const std::string& message,
-                               const MessageCallback& callback) {
-  callback.Run(message + kFakeEncodingSuffix);
+                               MessageCallback callback) {
+  std::move(callback).Run(message + kFakeEncodingSuffix);
 }
 
 void FakeSecureContext::Decode(const std::string& encoded_message,
-                               const MessageCallback& callback) {
+                               MessageCallback callback) {
   if (!EndsWith(encoded_message, kFakeEncodingSuffix,
                 base::CompareCase::SENSITIVE)) {
-    callback.Run(std::string());
+    std::move(callback).Run(std::string());
+    return;
   }
 
   std::string decoded_message = encoded_message;
   decoded_message.erase(decoded_message.size() - kFakeEncodingSuffixLen);
-  callback.Run(decoded_message);
+  std::move(callback).Run(decoded_message);
 }
 
 }  // namespace secure_channel

diff --git a/chromeos/services/secure_channel/fake_secure_context.h b/chromeos/services/secure_channel/fake_secure_context.h
index 7d5fbab..100a065 100644
--- a/chromeos/services/secure_channel/fake_secure_context.h
+++ b/chromeos/services/secure_channel/fake_secure_context.h

@@ -25,10 +25,9 @@
   // SecureContext:
   ProtocolVersion GetProtocolVersion() const override;
   std::string GetChannelBindingData() const override;
-  void Encode(const std::string& message,
-              const MessageCallback& callback) override;
+  void Encode(const std::string& message, MessageCallback callback) override;
   void Decode(const std::string& encoded_message,
-              const MessageCallback& callback) override;
+              MessageCallback callback) override;
 
   void set_protocol_version(ProtocolVersion protocol_version) {
     protocol_version_ = protocol_version;

diff --git a/chromeos/services/secure_channel/secure_context.h b/chromeos/services/secure_channel/secure_context.h
index a12dfd94..cf9b979a 100644
--- a/chromeos/services/secure_channel/secure_context.h
+++ b/chromeos/services/secure_channel/secure_context.h

@@ -14,7 +14,7 @@
 // An interface used to decode and encode messages.
 class SecureContext {
  public:
-  typedef base::Callback<void(const std::string& message)> MessageCallback;
+  typedef base::OnceCallback<void(const std::string& message)> MessageCallback;
 
   // The protocol version used during authentication.
   enum ProtocolVersion {
@@ -28,13 +28,12 @@
   // This function is asynchronous because the ChromeOS implementation requires
   // a DBus call.
   virtual void Decode(const std::string& encoded_message,
-                      const MessageCallback& callback) = 0;
+                      MessageCallback callback) = 0;
 
   // Encodes the |message| and returns the result.
   // This function is asynchronous because the ChromeOS implementation requires
   // a DBus call.
-  virtual void Encode(const std::string& message,
-                      const MessageCallback& callback) = 0;
+  virtual void Encode(const std::string& message, MessageCallback callback) = 0;
 
   // Returns the protocol version that was used during authentication.
   virtual ProtocolVersion GetProtocolVersion() const = 0;

diff --git a/components/arc/clipboard/arc_clipboard_bridge.h b/components/arc/clipboard/arc_clipboard_bridge.h
index 1056ad5..a08d1c8 100644
--- a/components/arc/clipboard/arc_clipboard_bridge.h
+++ b/components/arc/clipboard/arc_clipboard_bridge.h

@@ -36,6 +36,7 @@
 
   // ClipboardObserver overrides.
   void OnClipboardDataChanged() override;
+  void OnClipboardDataRead() override {}
 
   // mojom::ClipboardHost overrides.
   void SetClipContent(mojom::ClipDataPtr clip_data) override;

diff --git a/components/browser_ui/contacts_picker/android/BUILD.gn b/components/browser_ui/contacts_picker/android/BUILD.gn
new file mode 100644
index 0000000..03b5ed3
--- /dev/null
+++ b/components/browser_ui/contacts_picker/android/BUILD.gn

@@ -0,0 +1,114 @@
+# Copyright 2020 The Chromium Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+import("//build/config/android/rules.gni")
+
+source_set("android") {
+  sources = [
+    "contacts_picker_feature_list.cc",
+    "features.cc",
+    "features.h",
+  ]
+  deps = [
+    ":contacts_picker_jni_headers",
+    "//base",
+  ]
+}
+
+android_library("java") {
+  sources = [
+    "java/src/org/chromium/components/browser_ui/contacts_picker/CompressContactIconsWorkerTask.java",
+    "java/src/org/chromium/components/browser_ui/contacts_picker/ContactDetails.java",
+    "java/src/org/chromium/components/browser_ui/contacts_picker/ContactView.java",
+    "java/src/org/chromium/components/browser_ui/contacts_picker/ContactViewHolder.java",
+    "java/src/org/chromium/components/browser_ui/contacts_picker/ContactsFetcherWorkerTask.java",
+    "java/src/org/chromium/components/browser_ui/contacts_picker/ContactsPickerDialog.java",
+    "java/src/org/chromium/components/browser_ui/contacts_picker/ContactsPickerFeatureList.java",
+    "java/src/org/chromium/components/browser_ui/contacts_picker/ContactsPickerToolbar.java",
+    "java/src/org/chromium/components/browser_ui/contacts_picker/FetchIconWorkerTask.java",
+    "java/src/org/chromium/components/browser_ui/contacts_picker/PickerAdapter.java",
+    "java/src/org/chromium/components/browser_ui/contacts_picker/PickerCategoryView.java",
+    "java/src/org/chromium/components/browser_ui/contacts_picker/TopView.java",
+  ]
+  annotation_processor_deps = [ "//base/android/jni_generator:jni_processor" ]
+  resources_package = "org.chromium.components.browser_ui.contacts_picker"
+  deps = [
+    ":java_resources",
+    "//base:base_java",
+    "//base:jni_java",
+    "//components/browser_ui/util/android:java",
+    "//components/browser_ui/widget/android:java",
+    "//components/payments/mojom:mojom_java",
+    "//third_party/android_deps:androidx_annotation_annotation_java",
+    "//third_party/android_deps:androidx_appcompat_appcompat_java",
+    "//third_party/android_deps:androidx_core_core_java",
+    "//third_party/android_deps:androidx_recyclerview_recyclerview_java",
+    "//third_party/blink/public/mojom:android_mojo_bindings_java",
+    "//ui/android:ui_java",
+  ]
+  srcjar_deps = [
+    "//content/public/browser:contacts_picker_properties_requested_javagen",
+  ]
+}
+
+generate_jni("contacts_picker_jni_headers") {
+  sources = [ "java/src/org/chromium/components/browser_ui/contacts_picker/ContactsPickerFeatureList.java" ]
+}
+
+android_resources("java_resources") {
+  create_srcjar = false
+  sources = [
+    "java/res/drawable/address.xml",
+    "java/res/drawable/email.xml",
+    "java/res/drawable/face.xml",
+    "java/res/drawable/names.xml",
+    "java/res/drawable/telephone.xml",
+    "java/res/layout/checkbox_layout.xml",
+    "java/res/layout/contact_view.xml",
+    "java/res/layout/contacts_list_item_view.xml",
+    "java/res/layout/contacts_picker_dialog.xml",
+    "java/res/layout/contacts_picker_toolbar.xml",
+    "java/res/layout/top_view.xml",
+  ]
+  deps = [
+    "//components/browser_ui/strings/android:browser_ui_strings_grd",
+    "//components/browser_ui/styles/android:java_resources",
+    "//components/browser_ui/widget/android:java_resources",
+    "//ui/android:ui_java_resources",
+  ]
+}
+
+android_library("javatests") {
+  testonly = true
+
+  sources = [
+    "java/src/org/chromium/components/browser_ui/contacts_picker/ContactDetailsTest.java",
+    "java/src/org/chromium/components/browser_ui/contacts_picker/ContactsPickerDialogTest.java",
+  ]
+  deps = [
+    ":java",
+    ":java_resources",
+    "//base:base_java",
+    "//base:base_java_test_support",
+    "//chrome/test/android:chrome_java_test_support",
+    "//components/browser_ui/widget/android:java",
+    "//components/browser_ui/widget/android:test_support_java",
+    "//components/payments/mojom:mojom_java",
+    "//content/public/test/android:content_java_test_support",
+    "//third_party/android_deps:androidx_annotation_annotation_java",
+    "//third_party/android_deps:androidx_appcompat_appcompat_java",
+    "//third_party/android_deps:androidx_appcompat_appcompat_resources_java",
+    "//third_party/android_deps:androidx_core_core_java",
+    "//third_party/android_deps:androidx_recyclerview_recyclerview_java",
+    "//third_party/android_deps:androidx_test_runner_java",
+    "//third_party/android_support_test_runner:rules_java",
+    "//third_party/android_support_test_runner:runner_java",
+    "//third_party/blink/public/mojom:android_mojo_bindings_java",
+    "//third_party/junit",
+    "//third_party/mockito:mockito_java",
+    "//ui/android:ui_java",
+    "//ui/android:ui_java_test_support",
+  ]
+  resources_package = "org.chromium.components.browser_ui.contacts_picker.test"
+}

diff --git a/components/browser_ui/contacts_picker/android/DEPS b/components/browser_ui/contacts_picker/android/DEPS
new file mode 100644
index 0000000..aa76dcc2
--- /dev/null
+++ b/components/browser_ui/contacts_picker/android/DEPS

@@ -0,0 +1,6 @@
+include_rules = [
+  "+components/browser_ui/widget/android",
+  "+content/public/android",
+  "+content/public/test/android",
+  "+ui/android",
+]

diff --git a/components/browser_ui/contacts_picker/android/OWNERS b/components/browser_ui/contacts_picker/android/OWNERS
new file mode 100644
index 0000000..662f3e75
--- /dev/null
+++ b/components/browser_ui/contacts_picker/android/OWNERS

@@ -0,0 +1,6 @@
+finnur@chromium.org
+peter@chromium.org
+rayankans@chromium.org
+
+# COMPONENT: Blink>Contacts
+# TEAM: fugu-dev@chromium.org

diff --git a/components/browser_ui/contacts_picker/android/contacts_picker_feature_list.cc b/components/browser_ui/contacts_picker/android/contacts_picker_feature_list.cc
new file mode 100644
index 0000000..95195ed3
--- /dev/null
+++ b/components/browser_ui/contacts_picker/android/contacts_picker_feature_list.cc

@@ -0,0 +1,48 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/android/jni_string.h"
+#include "base/feature_list.h"
+#include "base/notreached.h"
+#include "base/stl_util.h"
+
+#include "components/browser_ui/contacts_picker/android/contacts_picker_jni_headers/ContactsPickerFeatureList_jni.h"
+#include "components/browser_ui/contacts_picker/android/features.h"
+
+using base::android::ConvertJavaStringToUTF8;
+using base::android::JavaParamRef;
+
+namespace browser_ui {
+
+namespace {
+
+// Array of features exposed through the Java ContentFeatureList API. Entries in
+// this array may either refer to features defined in the header of this file or
+// in other locations in the code base (e.g. content_features.h).
+const base::Feature* kFeaturesExposedToJava[] = {
+    &kContactsPickerSelectAll,
+};
+
+// TODO(crbug.com/1060097): Remove this once a generalized FeatureList exists.
+const base::Feature* FindFeatureExposedToJava(const std::string& feature_name) {
+  for (size_t i = 0; i < base::size(kFeaturesExposedToJava); ++i) {
+    if (kFeaturesExposedToJava[i]->name == feature_name)
+      return kFeaturesExposedToJava[i];
+  }
+  NOTREACHED() << "Queried feature not found in ContactsPickerFeatureList: "
+               << feature_name;
+  return nullptr;
+}
+
+}  // namespace
+
+static jboolean JNI_ContactsPickerFeatureList_IsEnabled(
+    JNIEnv* env,
+    const JavaParamRef<jstring>& jfeature_name) {
+  const base::Feature* feature =
+      FindFeatureExposedToJava(ConvertJavaStringToUTF8(env, jfeature_name));
+  return base::FeatureList::IsEnabled(*feature);
+}
+
+}  // namespace browser_ui

diff --git a/components/browser_ui/contacts_picker/android/features.cc b/components/browser_ui/contacts_picker/android/features.cc
new file mode 100644
index 0000000..84b4bed
--- /dev/null
+++ b/components/browser_ui/contacts_picker/android/features.cc

@@ -0,0 +1,15 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "components/browser_ui/contacts_picker/android/features.h"
+
+#include "base/feature_list.h"
+#include "base/metrics/field_trial_params.h"
+
+namespace browser_ui {
+
+const base::Feature kContactsPickerSelectAll{"ContactsPickerSelectAll",
+                                             base::FEATURE_DISABLED_BY_DEFAULT};
+
+}  // namespace browser_ui

diff --git a/components/browser_ui/contacts_picker/android/features.h b/components/browser_ui/contacts_picker/android/features.h
new file mode 100644
index 0000000..10d1382fc
--- /dev/null
+++ b/components/browser_ui/contacts_picker/android/features.h

@@ -0,0 +1,18 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef COMPONENTS_BROWSER_UI_CONTACTS_PICKER_ANDROID_FEATURES_H_
+#define COMPONENTS_BROWSER_UI_CONTACTS_PICKER_ANDROID_FEATURES_H_
+
+namespace base {
+struct Feature;
+}  // namespace base
+
+namespace browser_ui {
+
+extern const base::Feature kContactsPickerSelectAll;
+
+}  // namespace browser_ui
+
+#endif  // COMPONENTS_BROWSER_UI_CONTACTS_PICKER_ANDROID_FEATURES_H_

diff --git a/chrome/android/java/res/drawable/address.xml b/components/browser_ui/contacts_picker/android/java/res/drawable/address.xml
similarity index 100%
rename from chrome/android/java/res/drawable/address.xml
rename to components/browser_ui/contacts_picker/android/java/res/drawable/address.xml

diff --git a/chrome/android/java/res/drawable/email.xml b/components/browser_ui/contacts_picker/android/java/res/drawable/email.xml
similarity index 100%
rename from chrome/android/java/res/drawable/email.xml
rename to components/browser_ui/contacts_picker/android/java/res/drawable/email.xml

diff --git a/chrome/android/java/res/drawable/face.xml b/components/browser_ui/contacts_picker/android/java/res/drawable/face.xml
similarity index 100%
rename from chrome/android/java/res/drawable/face.xml
rename to components/browser_ui/contacts_picker/android/java/res/drawable/face.xml

diff --git a/chrome/android/java/res/drawable/names.xml b/components/browser_ui/contacts_picker/android/java/res/drawable/names.xml
similarity index 100%
rename from chrome/android/java/res/drawable/names.xml
rename to components/browser_ui/contacts_picker/android/java/res/drawable/names.xml

diff --git a/chrome/android/java/res/drawable/telephone.xml b/components/browser_ui/contacts_picker/android/java/res/drawable/telephone.xml
similarity index 100%
rename from chrome/android/java/res/drawable/telephone.xml
rename to components/browser_ui/contacts_picker/android/java/res/drawable/telephone.xml

diff --git a/chrome/android/java/res/layout/checkbox_layout.xml b/components/browser_ui/contacts_picker/android/java/res/layout/checkbox_layout.xml
similarity index 100%
rename from chrome/android/java/res/layout/checkbox_layout.xml
rename to components/browser_ui/contacts_picker/android/java/res/layout/checkbox_layout.xml

diff --git a/chrome/android/java/res/layout/contact_view.xml b/components/browser_ui/contacts_picker/android/java/res/layout/contact_view.xml
similarity index 82%
rename from chrome/android/java/res/layout/contact_view.xml
rename to components/browser_ui/contacts_picker/android/java/res/layout/contact_view.xml
index 724b9c14..5fa326df 100644
--- a/chrome/android/java/res/layout/contact_view.xml
+++ b/components/browser_ui/contacts_picker/android/java/res/layout/contact_view.xml

@@ -7,7 +7,7 @@
 
 <!-- Represents a single item in the Contacts Picker. -->
 
-<org.chromium.chrome.browser.contacts_picker.ContactView
+<org.chromium.components.browser_ui.contacts_picker.ContactView
     xmlns:android="http://schemas.android.com/apk/res/android"
     android:layout_height="wrap_content"
     android:layout_width="match_parent">
@@ -19,4 +19,4 @@
         <include layout="@layout/contacts_list_item_view" />
 
     </LinearLayout>
-</org.chromium.chrome.browser.contacts_picker.ContactView>
+</org.chromium.components.browser_ui.contacts_picker.ContactView>

diff --git a/chrome/android/java/res/layout/contacts_list_item_view.xml b/components/browser_ui/contacts_picker/android/java/res/layout/contacts_list_item_view.xml
similarity index 100%
rename from chrome/android/java/res/layout/contacts_list_item_view.xml
rename to components/browser_ui/contacts_picker/android/java/res/layout/contacts_list_item_view.xml

diff --git a/chrome/android/java/res/layout/contacts_picker_dialog.xml b/components/browser_ui/contacts_picker/android/java/res/layout/contacts_picker_dialog.xml
similarity index 100%
rename from chrome/android/java/res/layout/contacts_picker_dialog.xml
rename to components/browser_ui/contacts_picker/android/java/res/layout/contacts_picker_dialog.xml

diff --git a/chrome/android/java/res/layout/contacts_picker_toolbar.xml b/components/browser_ui/contacts_picker/android/java/res/layout/contacts_picker_toolbar.xml
similarity index 89%
rename from chrome/android/java/res/layout/contacts_picker_toolbar.xml
rename to components/browser_ui/contacts_picker/android/java/res/layout/contacts_picker_toolbar.xml
index 01e2537..572916b 100644
--- a/chrome/android/java/res/layout/contacts_picker_toolbar.xml
+++ b/components/browser_ui/contacts_picker/android/java/res/layout/contacts_picker_toolbar.xml

@@ -5,7 +5,7 @@
     found in the LICENSE file.
 -->
 
-<org.chromium.chrome.browser.contacts_picker.ContactsPickerToolbar
+<org.chromium.components.browser_ui.contacts_picker.ContactsPickerToolbar
     xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:app="http://schemas.android.com/apk/res-auto"
     android:layout_width="match_parent"
@@ -35,4 +35,4 @@
             android:text="@string/done"
             style="@style/TextButton" />
     </LinearLayout>
-</org.chromium.chrome.browser.contacts_picker.ContactsPickerToolbar>
+</org.chromium.components.browser_ui.contacts_picker.ContactsPickerToolbar>

diff --git a/chrome/android/java/res/layout/top_view.xml b/components/browser_ui/contacts_picker/android/java/res/layout/top_view.xml
similarity index 95%
rename from chrome/android/java/res/layout/top_view.xml
rename to components/browser_ui/contacts_picker/android/java/res/layout/top_view.xml
index 8230427..7af0502a 100644
--- a/chrome/android/java/res/layout/top_view.xml
+++ b/components/browser_ui/contacts_picker/android/java/res/layout/top_view.xml

@@ -3,7 +3,7 @@
      Use of this source code is governed by a BSD-style license that can be
      found in the LICENSE file. -->
 
-<org.chromium.chrome.browser.contacts_picker.TopView
+<org.chromium.components.browser_ui.contacts_picker.TopView
     xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:app="http://schemas.android.com/apk/res-auto"
     android:layout_width="match_parent"
@@ -72,4 +72,4 @@
 
         <include layout="@layout/checkbox_layout" />
     </LinearLayout>
-</org.chromium.chrome.browser.contacts_picker.TopView>
+</org.chromium.components.browser_ui.contacts_picker.TopView>

diff --git a/chrome/android/java/src/org/chromium/chrome/browser/contacts_picker/CompressContactIconsWorkerTask.java b/components/browser_ui/contacts_picker/android/java/src/org/chromium/components/browser_ui/contacts_picker/CompressContactIconsWorkerTask.java
similarity index 98%
rename from chrome/android/java/src/org/chromium/chrome/browser/contacts_picker/CompressContactIconsWorkerTask.java
rename to components/browser_ui/contacts_picker/android/java/src/org/chromium/components/browser_ui/contacts_picker/CompressContactIconsWorkerTask.java
index c6ca04e..122ac08 100644
--- a/chrome/android/java/src/org/chromium/chrome/browser/contacts_picker/CompressContactIconsWorkerTask.java
+++ b/components/browser_ui/contacts_picker/android/java/src/org/chromium/components/browser_ui/contacts_picker/CompressContactIconsWorkerTask.java

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-package org.chromium.chrome.browser.contacts_picker;
+package org.chromium.components.browser_ui.contacts_picker;
 
 import android.content.ContentResolver;
 import android.graphics.Bitmap;

diff --git a/chrome/android/java/src/org/chromium/chrome/browser/contacts_picker/ContactDetails.java b/components/browser_ui/contacts_picker/android/java/src/org/chromium/components/browser_ui/contacts_picker/ContactDetails.java
similarity index 98%
rename from chrome/android/java/src/org/chromium/chrome/browser/contacts_picker/ContactDetails.java
rename to components/browser_ui/contacts_picker/android/java/src/org/chromium/components/browser_ui/contacts_picker/ContactDetails.java
index a7d680d..3b71003f 100644
--- a/chrome/android/java/src/org/chromium/chrome/browser/contacts_picker/ContactDetails.java
+++ b/components/browser_ui/contacts_picker/android/java/src/org/chromium/components/browser_ui/contacts_picker/ContactDetails.java

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-package org.chromium.chrome.browser.contacts_picker;
+package org.chromium.components.browser_ui.contacts_picker;
 
 import android.content.res.Resources;
 import android.graphics.drawable.Drawable;
@@ -10,7 +10,6 @@
 import androidx.annotation.Nullable;
 
 import org.chromium.blink.mojom.ContactIconBlob;
-import org.chromium.chrome.R;
 import org.chromium.payments.mojom.PaymentAddress;
 
 import java.util.ArrayList;

diff --git a/chrome/android/javatests/src/org/chromium/chrome/browser/contacts_picker/ContactDetailsTest.java b/components/browser_ui/contacts_picker/android/java/src/org/chromium/components/browser_ui/contacts_picker/ContactDetailsTest.java
similarity index 94%
rename from chrome/android/javatests/src/org/chromium/chrome/browser/contacts_picker/ContactDetailsTest.java
rename to components/browser_ui/contacts_picker/android/java/src/org/chromium/components/browser_ui/contacts_picker/ContactDetailsTest.java
index cf9df16..2d9f625 100644
--- a/chrome/android/javatests/src/org/chromium/chrome/browser/contacts_picker/ContactDetailsTest.java
+++ b/components/browser_ui/contacts_picker/android/java/src/org/chromium/components/browser_ui/contacts_picker/ContactDetailsTest.java

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-package org.chromium.chrome.browser.contacts_picker;
+package org.chromium.components.browser_ui.contacts_picker;
 
 import android.content.Context;
 import android.content.res.Resources;
@@ -16,13 +16,10 @@
 
 import org.junit.Assert;
 import org.junit.Before;
-import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 
-import org.chromium.chrome.browser.app.ChromeActivity;
-import org.chromium.chrome.test.ChromeActivityTestRule;
-import org.chromium.chrome.test.ChromeJUnit4ClassRunner;
+import org.chromium.base.test.BaseJUnit4ClassRunner;
 import org.chromium.payments.mojom.PaymentAddress;
 
 import java.util.Arrays;
@@ -31,19 +28,13 @@
 /**
  * Tests for the ContactDetails class.
  */
-@RunWith(ChromeJUnit4ClassRunner.class)
+@RunWith(BaseJUnit4ClassRunner.class)
 public class ContactDetailsTest {
-    @Rule
-    public ChromeActivityTestRule<ChromeActivity> mActivityTestRule =
-            new ChromeActivityTestRule<>(ChromeActivity.class);
-
     Context mContext;
 
     @Before
     public void setUp() throws Exception {
-        mContext = InstrumentationRegistry.getInstrumentation()
-                           .getTargetContext()
-                           .getApplicationContext();
+        mContext = InstrumentationRegistry.getTargetContext();
     }
 
     private void compareAbbreviatedContactDetails(ContactDetails.AbbreviatedContactDetails expected,

diff --git a/chrome/android/java/src/org/chromium/chrome/browser/contacts_picker/ContactView.java b/components/browser_ui/contacts_picker/android/java/src/org/chromium/components/browser_ui/contacts_picker/ContactView.java
similarity index 98%
rename from chrome/android/java/src/org/chromium/chrome/browser/contacts_picker/ContactView.java
rename to components/browser_ui/contacts_picker/android/java/src/org/chromium/components/browser_ui/contacts_picker/ContactView.java
index 4e74542..6bb5b5d 100644
--- a/chrome/android/java/src/org/chromium/chrome/browser/contacts_picker/ContactView.java
+++ b/components/browser_ui/contacts_picker/android/java/src/org/chromium/components/browser_ui/contacts_picker/ContactView.java

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-package org.chromium.chrome.browser.contacts_picker;
+package org.chromium.components.browser_ui.contacts_picker;
 
 import android.content.Context;
 import android.content.res.Resources;
@@ -17,7 +17,6 @@
 import androidx.core.graphics.drawable.RoundedBitmapDrawable;
 import androidx.core.graphics.drawable.RoundedBitmapDrawableFactory;
 
-import org.chromium.chrome.R;
 import org.chromium.components.browser_ui.widget.selectable_list.SelectableItemView;
 import org.chromium.components.browser_ui.widget.selectable_list.SelectionDelegate;
 import org.chromium.ui.modaldialog.ModalDialogManager;

diff --git a/chrome/android/java/src/org/chromium/chrome/browser/contacts_picker/ContactViewHolder.java b/components/browser_ui/contacts_picker/android/java/src/org/chromium/components/browser_ui/contacts_picker/ContactViewHolder.java
similarity index 97%
rename from chrome/android/java/src/org/chromium/chrome/browser/contacts_picker/ContactViewHolder.java
rename to components/browser_ui/contacts_picker/android/java/src/org/chromium/components/browser_ui/contacts_picker/ContactViewHolder.java
index cecb7c0..c1badc2 100644
--- a/chrome/android/java/src/org/chromium/chrome/browser/contacts_picker/ContactViewHolder.java
+++ b/components/browser_ui/contacts_picker/android/java/src/org/chromium/components/browser_ui/contacts_picker/ContactViewHolder.java

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-package org.chromium.chrome.browser.contacts_picker;
+package org.chromium.components.browser_ui.contacts_picker;
 
 import android.content.ContentResolver;
 import android.graphics.Bitmap;

diff --git a/chrome/android/java/src/org/chromium/chrome/browser/contacts_picker/ContactsFetcherWorkerTask.java b/components/browser_ui/contacts_picker/android/java/src/org/chromium/components/browser_ui/contacts_picker/ContactsFetcherWorkerTask.java
similarity index 98%
rename from chrome/android/java/src/org/chromium/chrome/browser/contacts_picker/ContactsFetcherWorkerTask.java
rename to components/browser_ui/contacts_picker/android/java/src/org/chromium/components/browser_ui/contacts_picker/ContactsFetcherWorkerTask.java
index e6f6ff0..c0b9157 100644
--- a/chrome/android/java/src/org/chromium/chrome/browser/contacts_picker/ContactsFetcherWorkerTask.java
+++ b/components/browser_ui/contacts_picker/android/java/src/org/chromium/components/browser_ui/contacts_picker/ContactsFetcherWorkerTask.java

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-package org.chromium.chrome.browser.contacts_picker;
+package org.chromium.components.browser_ui.contacts_picker;
 
 import android.content.ContentResolver;
 import android.content.Context;
@@ -24,7 +24,8 @@
  */
 class ContactsFetcherWorkerTask extends AsyncTask<ArrayList<ContactDetails>> {
     private static final String[] PROJECTION = {
-            ContactsContract.Contacts._ID, ContactsContract.Contacts.LOOKUP_KEY,
+            ContactsContract.Contacts._ID,
+            ContactsContract.Contacts.LOOKUP_KEY,
             ContactsContract.Contacts.DISPLAY_NAME_PRIMARY,
     };
 

diff --git a/chrome/android/java/src/org/chromium/chrome/browser/contacts_picker/ContactsPickerDialog.java b/components/browser_ui/contacts_picker/android/java/src/org/chromium/components/browser_ui/contacts_picker/ContactsPickerDialog.java
similarity index 96%
rename from chrome/android/java/src/org/chromium/chrome/browser/contacts_picker/ContactsPickerDialog.java
rename to components/browser_ui/contacts_picker/android/java/src/org/chromium/components/browser_ui/contacts_picker/ContactsPickerDialog.java
index 9d45032b..0a1c47d0 100644
--- a/chrome/android/java/src/org/chromium/chrome/browser/contacts_picker/ContactsPickerDialog.java
+++ b/components/browser_ui/contacts_picker/android/java/src/org/chromium/components/browser_ui/contacts_picker/ContactsPickerDialog.java

@@ -2,12 +2,11 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-package org.chromium.chrome.browser.contacts_picker;
+package org.chromium.components.browser_ui.contacts_picker;
 
 import androidx.annotation.VisibleForTesting;
 import androidx.appcompat.app.AlertDialog;
 
-import org.chromium.chrome.R;
 import org.chromium.ui.ContactsPickerListener;
 import org.chromium.ui.base.WindowAndroid;
 import org.chromium.ui.vr.VrModeProvider;

diff --git a/chrome/android/javatests/src/org/chromium/chrome/browser/contacts_picker/ContactsPickerDialogTest.java b/components/browser_ui/contacts_picker/android/java/src/org/chromium/components/browser_ui/contacts_picker/ContactsPickerDialogTest.java
similarity index 94%
rename from chrome/android/javatests/src/org/chromium/chrome/browser/contacts_picker/ContactsPickerDialogTest.java
rename to components/browser_ui/contacts_picker/android/java/src/org/chromium/components/browser_ui/contacts_picker/ContactsPickerDialogTest.java
index 36f5fda..c910286 100644
--- a/chrome/android/javatests/src/org/chromium/chrome/browser/contacts_picker/ContactsPickerDialogTest.java
+++ b/components/browser_ui/contacts_picker/android/java/src/org/chromium/components/browser_ui/contacts_picker/ContactsPickerDialogTest.java

@@ -2,8 +2,9 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-package org.chromium.chrome.browser.contacts_picker;
+package org.chromium.components.browser_ui.contacts_picker;
 
+import android.content.Context;
 import android.graphics.Bitmap;
 import android.graphics.Canvas;
 import android.graphics.Color;
@@ -22,19 +23,15 @@
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
 
+import org.chromium.base.FeatureList;
+import org.chromium.base.test.BaseJUnit4ClassRunner;
 import org.chromium.base.test.util.CallbackHelper;
-import org.chromium.base.test.util.CommandLineFlags;
 import org.chromium.base.test.util.Feature;
 import org.chromium.blink.mojom.ContactIconBlob;
-import org.chromium.chrome.R;
-import org.chromium.chrome.browser.app.ChromeActivity;
-import org.chromium.chrome.browser.flags.ChromeFeatureList;
-import org.chromium.chrome.browser.flags.ChromeSwitches;
-import org.chromium.chrome.test.ChromeActivityTestRule;
-import org.chromium.chrome.test.ChromeJUnit4ClassRunner;
-import org.chromium.chrome.test.util.ChromeRenderTestRule;
-import org.chromium.chrome.test.util.browser.Features;
 import org.chromium.components.browser_ui.widget.RecyclerViewTestUtils;
 import org.chromium.components.browser_ui.widget.selectable_list.SelectionDelegate;
 import org.chromium.components.browser_ui.widget.selectable_list.SelectionDelegate.SelectionObserver;
@@ -42,35 +39,36 @@
 import org.chromium.content_public.browser.test.util.TestTouchUtils;
 import org.chromium.payments.mojom.PaymentAddress;
 import org.chromium.ui.ContactsPickerListener;
+import org.chromium.ui.base.WindowAndroid;
 import org.chromium.ui.test.util.DisableAnimationsTestRule;
+import org.chromium.ui.test.util.DummyUiActivityTestCase;
+import org.chromium.ui.test.util.RenderTestRule;
 import org.chromium.ui.vr.VrModeObserver;
 import org.chromium.ui.vr.VrModeProvider;
 
+import java.lang.ref.WeakReference;
 import java.nio.ByteBuffer;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 import java.util.concurrent.Callable;
 
 /**
  * Tests for the ContactsPickerDialog class.
  */
-@RunWith(ChromeJUnit4ClassRunner.class)
-@Features.EnableFeatures({ChromeFeatureList.CONTACTS_PICKER_SELECT_ALL})
-@CommandLineFlags.Add({ChromeSwitches.DISABLE_FIRST_RUN_EXPERIENCE})
-public class ContactsPickerDialogTest
+@RunWith(BaseJUnit4ClassRunner.class)
+public class ContactsPickerDialogTest extends DummyUiActivityTestCase
         implements ContactsPickerListener, SelectionObserver<ContactDetails> {
     @ClassRule
     public static DisableAnimationsTestRule mDisableAnimationsTestRule =
             new DisableAnimationsTestRule();
 
-    @Rule
-    public ChromeActivityTestRule<ChromeActivity> mActivityTestRule =
-            new ChromeActivityTestRule<>(ChromeActivity.class);
+    @Mock
+    private WindowAndroid mWindowAndroid;
 
     @Rule
-    public ChromeRenderTestRule mRenderTestRule =
-            ChromeRenderTestRule.Builder.withPublicCorpus().build();
+    public RenderTestRule mRenderTestRule = RenderTestRule.Builder.withPublicCorpus().build();
 
     // The dialog we are testing.
     private ContactsPickerDialog mDialog;
@@ -114,7 +112,12 @@
 
     @Before
     public void setUp() throws Exception {
-        mActivityTestRule.startMainActivityOnBlankPage();
+        MockitoAnnotations.initMocks(this);
+        Mockito.doReturn(new WeakReference<Context>(getActivity()))
+                .when(mWindowAndroid)
+                .getContext();
+        FeatureList.setTestFeatures(Collections.singletonMap(
+                ContactsPickerFeatureList.CONTACTS_PICKER_SELECT_ALL, true));
         mIcon = Bitmap.createBitmap(100, 100, Bitmap.Config.ARGB_8888);
         Canvas canvas = new Canvas(mIcon);
         canvas.drawColor(Color.BLUE);
@@ -168,11 +171,19 @@
                 TestThreadUtils.runOnUiThreadBlocking(new Callable<ContactsPickerDialog>() {
                     @Override
                     public ContactsPickerDialog call() {
-                        final ContactsPickerDialog dialog = new ContactsPickerDialog(
-                                mActivityTestRule.getActivity().getWindowAndroid(),
-                                new ChromePickerAdapter(), ContactsPickerDialogTest.this,
-                                multiselect, includeNames, includeEmails, includeTel,
-                                includeAddresses, includeIcons, "example.com",
+                        final ContactsPickerDialog dialog = new ContactsPickerDialog(mWindowAndroid,
+                                new PickerAdapter() {
+                                    @Override
+                                    protected String findOwnerEmail() {
+                                        return null;
+                                    }
+                                    @Override
+                                    protected void addOwnerInfoToContacts(
+                                            ArrayList<ContactDetails> contacts) {}
+                                },
+                                ContactsPickerDialogTest.this, multiselect, includeNames,
+                                includeEmails, includeTel, includeAddresses, includeIcons,
+                                "example.com",
                                 new VrModeProvider() {
                                     @Override
                                     public boolean isInVr() {
@@ -258,7 +269,7 @@
         mLastActionRecorded = ContactsPickerAction.NUM_ENTRIES;
 
         PickerCategoryView categoryView = mDialog.getCategoryViewForTesting();
-        View cancel = new View(mActivityTestRule.getActivity());
+        View cancel = new View(getActivity());
         int callCount = onActionCallback.getCallCount();
         categoryView.onClick(cancel);
         onActionCallback.waitForCallback(callCount, 1);

diff --git a/components/browser_ui/contacts_picker/android/java/src/org/chromium/components/browser_ui/contacts_picker/ContactsPickerFeatureList.java b/components/browser_ui/contacts_picker/android/java/src/org/chromium/components/browser_ui/contacts_picker/ContactsPickerFeatureList.java
new file mode 100644
index 0000000..bc6fb63
--- /dev/null
+++ b/components/browser_ui/contacts_picker/android/java/src/org/chromium/components/browser_ui/contacts_picker/ContactsPickerFeatureList.java

@@ -0,0 +1,44 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package org.chromium.components.browser_ui.contacts_picker;
+
+import org.chromium.base.FeatureList;
+import org.chromium.base.annotations.JNINamespace;
+import org.chromium.base.annotations.MainDex;
+import org.chromium.base.annotations.NativeMethods;
+
+/**
+ * Provides an API for querying the status of Contacts Picker features.
+ */
+// TODO(crbug.com/1060097): Remove/update this once a generalized FeatureList exists.
+@JNINamespace("browser_ui")
+@MainDex
+public class ContactsPickerFeatureList {
+    public static final String CONTACTS_PICKER_SELECT_ALL = "ContactsPickerSelectAll";
+
+    private ContactsPickerFeatureList() {}
+
+    /**
+     * Returns whether the specified feature is enabled or not.
+     *
+     * Note: Features queried through this API must be added to the array
+     * |kFeaturesExposedToJava| in
+     * //components/browser_ui/contacts_picker/android/contacts_picker_feature_list.cc
+     *
+     * @param featureName The name of the feature to query.
+     * @return Whether the feature is enabled or not.
+     */
+    public static boolean isEnabled(String featureName) {
+        Boolean testValue = FeatureList.getTestValueForFeature(featureName);
+        if (testValue != null) return testValue;
+        assert FeatureList.isNativeInitialized();
+        return ContactsPickerFeatureListJni.get().isEnabled(featureName);
+    }
+
+    @NativeMethods
+    interface Natives {
+        boolean isEnabled(String featureName);
+    }
+}

diff --git a/chrome/android/java/src/org/chromium/chrome/browser/contacts_picker/ContactsPickerToolbar.java b/components/browser_ui/contacts_picker/android/java/src/org/chromium/components/browser_ui/contacts_picker/ContactsPickerToolbar.java
similarity index 97%
rename from chrome/android/java/src/org/chromium/chrome/browser/contacts_picker/ContactsPickerToolbar.java
rename to components/browser_ui/contacts_picker/android/java/src/org/chromium/components/browser_ui/contacts_picker/ContactsPickerToolbar.java
index 1b494b87..8ca0750 100644
--- a/chrome/android/java/src/org/chromium/chrome/browser/contacts_picker/ContactsPickerToolbar.java
+++ b/components/browser_ui/contacts_picker/android/java/src/org/chromium/components/browser_ui/contacts_picker/ContactsPickerToolbar.java

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-package org.chromium.chrome.browser.contacts_picker;
+package org.chromium.components.browser_ui.contacts_picker;
 
 import android.content.Context;
 import android.util.AttributeSet;
@@ -11,7 +11,6 @@
 import androidx.core.widget.ImageViewCompat;
 
 import org.chromium.base.ApiCompatibilityUtils;
-import org.chromium.chrome.R;
 import org.chromium.components.browser_ui.widget.selectable_list.SelectableListToolbar;
 import org.chromium.components.browser_ui.widget.selectable_list.SelectionDelegate;
 import org.chromium.ui.vr.VrModeProvider;

diff --git a/chrome/android/java/src/org/chromium/chrome/browser/contacts_picker/FetchIconWorkerTask.java b/components/browser_ui/contacts_picker/android/java/src/org/chromium/components/browser_ui/contacts_picker/FetchIconWorkerTask.java
similarity index 97%
rename from chrome/android/java/src/org/chromium/chrome/browser/contacts_picker/FetchIconWorkerTask.java
rename to components/browser_ui/contacts_picker/android/java/src/org/chromium/components/browser_ui/contacts_picker/FetchIconWorkerTask.java
index 6bb6f2d..70c3084 100644
--- a/chrome/android/java/src/org/chromium/chrome/browser/contacts_picker/FetchIconWorkerTask.java
+++ b/components/browser_ui/contacts_picker/android/java/src/org/chromium/components/browser_ui/contacts_picker/FetchIconWorkerTask.java

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-package org.chromium.chrome.browser.contacts_picker;
+package org.chromium.components.browser_ui.contacts_picker;
 
 import android.content.ContentResolver;
 import android.content.ContentUris;

diff --git a/chrome/android/java/src/org/chromium/chrome/browser/contacts_picker/PickerAdapter.java b/components/browser_ui/contacts_picker/android/java/src/org/chromium/components/browser_ui/contacts_picker/PickerAdapter.java
similarity index 98%
rename from chrome/android/java/src/org/chromium/chrome/browser/contacts_picker/PickerAdapter.java
rename to components/browser_ui/contacts_picker/android/java/src/org/chromium/components/browser_ui/contacts_picker/PickerAdapter.java
index 4a1c584f..d27294e 100644
--- a/chrome/android/java/src/org/chromium/chrome/browser/contacts_picker/PickerAdapter.java
+++ b/components/browser_ui/contacts_picker/android/java/src/org/chromium/components/browser_ui/contacts_picker/PickerAdapter.java

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-package org.chromium.chrome.browser.contacts_picker;
+package org.chromium.components.browser_ui.contacts_picker;
 
 import android.content.ContentResolver;
 import android.content.Context;
@@ -19,7 +19,6 @@
 import androidx.recyclerview.widget.RecyclerView.Adapter;
 
 import org.chromium.base.task.AsyncTask;
-import org.chromium.chrome.R;
 
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;

diff --git a/chrome/android/java/src/org/chromium/chrome/browser/contacts_picker/PickerCategoryView.java b/components/browser_ui/contacts_picker/android/java/src/org/chromium/components/browser_ui/contacts_picker/PickerCategoryView.java
similarity index 98%
rename from chrome/android/java/src/org/chromium/chrome/browser/contacts_picker/PickerCategoryView.java
rename to components/browser_ui/contacts_picker/android/java/src/org/chromium/components/browser_ui/contacts_picker/PickerCategoryView.java
index 752c8b8..aad6ce2 100644
--- a/chrome/android/java/src/org/chromium/chrome/browser/contacts_picker/PickerCategoryView.java
+++ b/components/browser_ui/contacts_picker/android/java/src/org/chromium/components/browser_ui/contacts_picker/PickerCategoryView.java

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-package org.chromium.chrome.browser.contacts_picker;
+package org.chromium.components.browser_ui.contacts_picker;
 
 import android.content.Context;
 import android.content.DialogInterface;
@@ -20,7 +20,6 @@
 import org.chromium.base.ApiCompatibilityUtils;
 import org.chromium.base.metrics.RecordHistogram;
 import org.chromium.base.task.AsyncTask;
-import org.chromium.chrome.R;
 import org.chromium.components.browser_ui.util.BitmapCache;
 import org.chromium.components.browser_ui.util.ConversionUtils;
 import org.chromium.components.browser_ui.util.GlobalDiscardableReferencePool;
@@ -171,8 +170,7 @@
         View root = LayoutInflater.from(context).inflate(R.layout.contacts_picker_dialog, this);
         mSelectableListLayout =
                 (SelectableListLayout<ContactDetails>) root.findViewById(R.id.selectable_list);
-        mSelectableListLayout.initializeEmptyView(
-                R.string.contacts_picker_no_contacts_found,
+        mSelectableListLayout.initializeEmptyView(R.string.contacts_picker_no_contacts_found,
                 R.string.contacts_picker_no_contacts_found);
 
         mPickerAdapter = adapter;

diff --git a/chrome/android/java/src/org/chromium/chrome/browser/contacts_picker/TopView.java b/components/browser_ui/contacts_picker/android/java/src/org/chromium/components/browser_ui/contacts_picker/TopView.java
similarity index 96%
rename from chrome/android/java/src/org/chromium/chrome/browser/contacts_picker/TopView.java
rename to components/browser_ui/contacts_picker/android/java/src/org/chromium/components/browser_ui/contacts_picker/TopView.java
index b5cbf4a..4b41ead 100644
--- a/chrome/android/java/src/org/chromium/chrome/browser/contacts_picker/TopView.java
+++ b/components/browser_ui/contacts_picker/android/java/src/org/chromium/components/browser_ui/contacts_picker/TopView.java

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-package org.chromium.chrome.browser.contacts_picker;
+package org.chromium.components.browser_ui.contacts_picker;
 
 import android.content.Context;
 import android.text.style.StyleSpan;
@@ -13,8 +13,6 @@
 import android.widget.RelativeLayout;
 import android.widget.TextView;
 
-import org.chromium.chrome.R;
-import org.chromium.chrome.browser.flags.ChromeFeatureList;
 import org.chromium.ui.text.SpanApplier;
 import org.chromium.ui.widget.ChipView;
 
@@ -92,7 +90,8 @@
         super.onFinishInflate();
 
         mCheckboxContainer = findViewById(R.id.content);
-        if (ChromeFeatureList.isEnabled(ChromeFeatureList.CONTACTS_PICKER_SELECT_ALL)) {
+        if (ContactsPickerFeatureList.isEnabled(
+                    ContactsPickerFeatureList.CONTACTS_PICKER_SELECT_ALL)) {
             mCheckboxContainer.setVisibility(View.VISIBLE);
         }
         mSelectAllBox = findViewById(R.id.checkbox);
@@ -260,7 +259,8 @@
      * Toggles the Select All checkbox.
      */
     public void toggle() {
-        if (ChromeFeatureList.isEnabled(ChromeFeatureList.CONTACTS_PICKER_SELECT_ALL)) {
+        if (ContactsPickerFeatureList.isEnabled(
+                    ContactsPickerFeatureList.CONTACTS_PICKER_SELECT_ALL)) {
             mSelectAllBox.setChecked(!mSelectAllBox.isChecked());
         }
     }

diff --git a/components/browser_ui/strings/android/browser_ui_strings.grd b/components/browser_ui/strings/android/browser_ui_strings.grd
index dc57dbce..55f1e3e 100644
--- a/components/browser_ui/strings/android/browser_ui_strings.grd
+++ b/components/browser_ui/strings/android/browser_ui_strings.grd

@@ -588,7 +588,7 @@
         Options available near bottom of the screen
       </message>
 
-    <!-- Warning on sharing info with external apps in incognito mode -->
+      <!-- Warning on sharing info with external apps in incognito mode -->
       <message name="IDS_EXTERNAL_APP_LEAVE_INCOGNITO_WARNING" desc="Alert dialog text warning the user (who is currently in incognito mode) that the site they are currently using is going to share data with an external application." formatter_data="android_java">
         This site is about to share information with an app outside of incognito mode.
       </message>
@@ -602,6 +602,46 @@
         Leave
       </message>
 
+      <!-- Contacts Picker strings -->
+      <message name="IDS_CONTACTS_PICKER_SEARCH" desc="The hint text for the search box for contacts.">
+        Search your contacts
+      </message>
+      <message name="IDS_CONTACTS_PICKER_SELECT_CONTACTS" desc="The label at the top of the dialog that allows users to select contacts from their device and share the details with a web page.">
+        Select contacts
+      </message>
+      <message name="IDS_CONTACTS_PICKER_SELECT_CONTACT" desc="The label at the top of the dialog that allows users to select a single contact from their device and share the details with a web page.">
+        Select a contact
+      </message>
+      <message name="IDS_CONTACTS_PICKER_ALL_CONTACTS" desc="The label associated with the select all checkbox, indicating that all the contacts will be selected.">
+        All contacts
+      </message>
+      <message name="IDS_CONTACTS_PICKER_NO_CONTACTS_FOUND" desc="The label shown when no contacts are found (e.g. none exist on the device).">
+        No contacts found
+      </message>
+      <message name="IDS_TOP_VIEW_NAMES_FILTER_LABEL" desc="The label shown for the names filter toggle button (allowing the user to exclude names).">
+        Names
+      </message>
+      <message name="IDS_TOP_VIEW_ADDRESS_FILTER_LABEL" desc="The label shown for the address filter toggle button (allowing the user to exclude names).">
+        Addresses
+      </message>
+      <message name="IDS_TOP_VIEW_EMAIL_FILTER_LABEL" desc="The label shown for the email filter toggle button (allowing the user to exclude emails).">
+        Email addresses
+      </message>
+      <message name="IDS_TOP_VIEW_TELEPHONE_FILTER_LABEL" desc="The label shown for the telephone filter toggle button (allowing the user to exclude telephones).">
+        Phone numbers
+      </message>
+      <message name="IDS_TOP_VIEW_ICON_FILTER_LABEL" desc="The label shown for the icon filter toggle button (allowing the user to exclude icons).">
+        Profile photos
+      </message>
+      <message name="IDS_CONTACTS_PICKER_MORE_DETAILS" desc="Label describing that the user has one or more telephone/emails (used for either).">
+        {DETAIL_COUNT, plural,
+          =1 {(+ 1 more)}
+          other {(+ # more)}}
+      </message>
+      <message name="IDS_DISCLAIMER_SHARING_CONTACT_DETAILS" desc="Label describing what will happen with the contact details that are being shared.">
+        The contacts you select will be shared with <ph name="BEGIN_BOLD">&lt;b&gt;</ph><ph name="SITE">%1$s<ex>https://www.google.com</ex></ph><ph name="END_BOLD">&lt;/b&gt;</ph>.
+      </message>
+
       <!-- Photo picker -->
       <message name="IDS_PHOTO_PICKER_SELECT_IMAGES" desc="The label in the title bar of the Photo Picker dialog, suggesting that the user can make multiple selections.">
         Select images

diff --git a/chrome/browser/ui/android/strings/android_chrome_strings_grd/IDS_CONTACTS_PICKER_ALL_CONTACTS.png.sha1 b/components/browser_ui/strings/android/browser_ui_strings_grd/IDS_CONTACTS_PICKER_ALL_CONTACTS.png.sha1
similarity index 100%
rename from chrome/browser/ui/android/strings/android_chrome_strings_grd/IDS_CONTACTS_PICKER_ALL_CONTACTS.png.sha1
rename to components/browser_ui/strings/android/browser_ui_strings_grd/IDS_CONTACTS_PICKER_ALL_CONTACTS.png.sha1

diff --git a/chrome/browser/ui/android/strings/android_chrome_strings_grd/IDS_CONTACTS_PICKER_MORE_DETAILS.png.sha1 b/components/browser_ui/strings/android/browser_ui_strings_grd/IDS_CONTACTS_PICKER_MORE_DETAILS.png.sha1
similarity index 100%
rename from chrome/browser/ui/android/strings/android_chrome_strings_grd/IDS_CONTACTS_PICKER_MORE_DETAILS.png.sha1
rename to components/browser_ui/strings/android/browser_ui_strings_grd/IDS_CONTACTS_PICKER_MORE_DETAILS.png.sha1

diff --git a/chrome/browser/ui/android/strings/android_chrome_strings_grd/IDS_CONTACTS_PICKER_NO_CONTACTS_FOUND.png.sha1 b/components/browser_ui/strings/android/browser_ui_strings_grd/IDS_CONTACTS_PICKER_NO_CONTACTS_FOUND.png.sha1
similarity index 100%
rename from chrome/browser/ui/android/strings/android_chrome_strings_grd/IDS_CONTACTS_PICKER_NO_CONTACTS_FOUND.png.sha1
rename to components/browser_ui/strings/android/browser_ui_strings_grd/IDS_CONTACTS_PICKER_NO_CONTACTS_FOUND.png.sha1

diff --git a/chrome/browser/ui/android/strings/android_chrome_strings_grd/IDS_CONTACTS_PICKER_SEARCH.png.sha1 b/components/browser_ui/strings/android/browser_ui_strings_grd/IDS_CONTACTS_PICKER_SEARCH.png.sha1
similarity index 100%
rename from chrome/browser/ui/android/strings/android_chrome_strings_grd/IDS_CONTACTS_PICKER_SEARCH.png.sha1
rename to components/browser_ui/strings/android/browser_ui_strings_grd/IDS_CONTACTS_PICKER_SEARCH.png.sha1

diff --git a/chrome/browser/ui/android/strings/android_chrome_strings_grd/IDS_CONTACTS_PICKER_SELECT_CONTACTS.png.sha1 b/components/browser_ui/strings/android/browser_ui_strings_grd/IDS_CONTACTS_PICKER_SELECT_CONTACTS.png.sha1
similarity index 100%
rename from chrome/browser/ui/android/strings/android_chrome_strings_grd/IDS_CONTACTS_PICKER_SELECT_CONTACTS.png.sha1
rename to components/browser_ui/strings/android/browser_ui_strings_grd/IDS_CONTACTS_PICKER_SELECT_CONTACTS.png.sha1

diff --git a/chrome/browser/ui/android/strings/android_chrome_strings_grd/IDS_DISCLAIMER_SHARING_CONTACT_DETAILS.png.sha1 b/components/browser_ui/strings/android/browser_ui_strings_grd/IDS_DISCLAIMER_SHARING_CONTACT_DETAILS.png.sha1
similarity index 100%
rename from chrome/browser/ui/android/strings/android_chrome_strings_grd/IDS_DISCLAIMER_SHARING_CONTACT_DETAILS.png.sha1
rename to components/browser_ui/strings/android/browser_ui_strings_grd/IDS_DISCLAIMER_SHARING_CONTACT_DETAILS.png.sha1

diff --git a/chrome/browser/ui/android/strings/android_chrome_strings_grd/IDS_TOP_VIEW_ICON_FILTER_LABEL.png.sha1 b/components/browser_ui/strings/android/browser_ui_strings_grd/IDS_TOP_VIEW_ICON_FILTER_LABEL.png.sha1
similarity index 100%
rename from chrome/browser/ui/android/strings/android_chrome_strings_grd/IDS_TOP_VIEW_ICON_FILTER_LABEL.png.sha1
rename to components/browser_ui/strings/android/browser_ui_strings_grd/IDS_TOP_VIEW_ICON_FILTER_LABEL.png.sha1

diff --git a/chrome/browser/ui/android/strings/android_chrome_strings_grd/IDS_TOP_VIEW_TELEPHONE_FILTER_LABEL.png.sha1 b/components/browser_ui/strings/android/browser_ui_strings_grd/IDS_TOP_VIEW_TELEPHONE_FILTER_LABEL.png.sha1
similarity index 100%
rename from chrome/browser/ui/android/strings/android_chrome_strings_grd/IDS_TOP_VIEW_TELEPHONE_FILTER_LABEL.png.sha1
rename to components/browser_ui/strings/android/browser_ui_strings_grd/IDS_TOP_VIEW_TELEPHONE_FILTER_LABEL.png.sha1

diff --git a/components/browser_ui/styles/android/BUILD.gn b/components/browser_ui/styles/android/BUILD.gn
index 01e4bcd..b6e8a85c 100644
--- a/components/browser_ui/styles/android/BUILD.gn
+++ b/components/browser_ui/styles/android/BUILD.gn

@@ -26,6 +26,7 @@
     "java/res/color/default_icon_color_secondary_light_tint_list.xml",
     "java/res/color/default_icon_color_secondary_tint_list.xml",
     "java/res/color/default_icon_color_tint_list.xml",
+    "java/res/drawable-hdpi/btn_star_filled.png",
     "java/res/drawable-hdpi/ic_delete_white_24dp.png",
     "java/res/drawable-hdpi/ic_folder_blue_24dp.png",
     "java/res/drawable-hdpi/ic_logo_googleg_24dp.png",
@@ -41,6 +42,7 @@
     "java/res/drawable-hdpi/plus.png",
     "java/res/drawable-hdpi/settings_all_sites.png",
     "java/res/drawable-hdpi/top_round.9.png",
+    "java/res/drawable-mdpi/btn_star_filled.png",
     "java/res/drawable-mdpi/ic_delete_white_24dp.png",
     "java/res/drawable-mdpi/ic_folder_blue_24dp.png",
     "java/res/drawable-mdpi/ic_logo_googleg_24dp.png",
@@ -61,6 +63,7 @@
     "java/res/drawable-night-xhdpi/top_round.9.png",
     "java/res/drawable-night-xxhdpi/top_round.9.png",
     "java/res/drawable-night-xxxhdpi/top_round.9.png",
+    "java/res/drawable-xhdpi/btn_star_filled.png",
     "java/res/drawable-xhdpi/ic_delete_white_24dp.png",
     "java/res/drawable-xhdpi/ic_folder_blue_24dp.png",
     "java/res/drawable-xhdpi/ic_logo_googleg_24dp.png",
@@ -76,6 +79,7 @@
     "java/res/drawable-xhdpi/plus.png",
     "java/res/drawable-xhdpi/settings_all_sites.png",
     "java/res/drawable-xhdpi/top_round.9.png",
+    "java/res/drawable-xxhdpi/btn_star_filled.png",
     "java/res/drawable-xxhdpi/ic_delete_white_24dp.png",
     "java/res/drawable-xxhdpi/ic_folder_blue_24dp.png",
     "java/res/drawable-xxhdpi/ic_logo_googleg_24dp.png",
@@ -91,6 +95,7 @@
     "java/res/drawable-xxhdpi/plus.png",
     "java/res/drawable-xxhdpi/settings_all_sites.png",
     "java/res/drawable-xxhdpi/top_round.9.png",
+    "java/res/drawable-xxxhdpi/btn_star_filled.png",
     "java/res/drawable-xxxhdpi/ic_delete_white_24dp.png",
     "java/res/drawable-xxxhdpi/ic_folder_blue_24dp.png",
     "java/res/drawable-xxxhdpi/ic_logo_googleg_24dp.png",

diff --git a/chrome/android/java/res/drawable-hdpi/btn_star_filled.png b/components/browser_ui/styles/android/java/res/drawable-hdpi/btn_star_filled.png
similarity index 100%
rename from chrome/android/java/res/drawable-hdpi/btn_star_filled.png
rename to components/browser_ui/styles/android/java/res/drawable-hdpi/btn_star_filled.png
Binary files differ

diff --git a/chrome/android/java/res/drawable-mdpi/btn_star_filled.png b/components/browser_ui/styles/android/java/res/drawable-mdpi/btn_star_filled.png
similarity index 100%
rename from chrome/android/java/res/drawable-mdpi/btn_star_filled.png
rename to components/browser_ui/styles/android/java/res/drawable-mdpi/btn_star_filled.png
Binary files differ

diff --git a/chrome/android/java/res/drawable-xhdpi/btn_star_filled.png b/components/browser_ui/styles/android/java/res/drawable-xhdpi/btn_star_filled.png
similarity index 100%
rename from chrome/android/java/res/drawable-xhdpi/btn_star_filled.png
rename to components/browser_ui/styles/android/java/res/drawable-xhdpi/btn_star_filled.png
Binary files differ

diff --git a/chrome/android/java/res/drawable-xxhdpi/btn_star_filled.png b/components/browser_ui/styles/android/java/res/drawable-xxhdpi/btn_star_filled.png
similarity index 100%
rename from chrome/android/java/res/drawable-xxhdpi/btn_star_filled.png
rename to components/browser_ui/styles/android/java/res/drawable-xxhdpi/btn_star_filled.png
Binary files differ

diff --git a/chrome/android/java/res/drawable-xxxhdpi/btn_star_filled.png b/components/browser_ui/styles/android/java/res/drawable-xxxhdpi/btn_star_filled.png
similarity index 100%
rename from chrome/android/java/res/drawable-xxxhdpi/btn_star_filled.png
rename to components/browser_ui/styles/android/java/res/drawable-xxxhdpi/btn_star_filled.png
Binary files differ

diff --git a/components/browser_ui/styles/android/java/res/values/colors.xml b/components/browser_ui/styles/android/java/res/values/colors.xml
index 7ec9515..a24b7d5f 100644
--- a/components/browser_ui/styles/android/java/res/values/colors.xml
+++ b/components/browser_ui/styles/android/java/res/values/colors.xml

@@ -28,6 +28,9 @@
         @color/default_control_color_highlight_light
     </color>
 
+    <!-- Favicons -->
+    <color name="default_favicon_background_color">@color/default_control_color_normal_light</color>
+
     <!-- Navigation bar colors -->
     <color name="bottom_system_nav_color">@color/modern_white</color>
     <color name="bottom_system_nav_divider_color">@color/black_alpha_12</color>

diff --git a/components/content_capture/android/BUILD.gn b/components/content_capture/android/BUILD.gn
index 353ba7e..0b607fd 100644
--- a/components/content_capture/android/BUILD.gn
+++ b/components/content_capture/android/BUILD.gn

@@ -38,6 +38,7 @@
     "java/src/org/chromium/components/content_capture/ContentCapturedTask.java",
     "java/src/org/chromium/components/content_capture/ContentRemovedTask.java",
     "java/src/org/chromium/components/content_capture/ContentUpdateTask.java",
+    "java/src/org/chromium/components/content_capture/ExperimentContentCaptureConsumer.java",
     "java/src/org/chromium/components/content_capture/FrameSession.java",
     "java/src/org/chromium/components/content_capture/NotificationTask.java",
     "java/src/org/chromium/components/content_capture/PlatformSession.java",

diff --git a/components/content_capture/android/content_capture_controller.cc b/components/content_capture/android/content_capture_controller.cc
index 13829efb..c019c47 100644
--- a/components/content_capture/android/content_capture_controller.cc
+++ b/components/content_capture/android/content_capture_controller.cc

@@ -93,4 +93,17 @@
   return false;
 }
 
+bool ContentCaptureController::ShouldCapture(
+    JNIEnv* env,
+    const base::android::JavaParamRef<jobject>& jcaller,
+    const base::android::JavaParamRef<jobjectArray>& urls) {
+  std::vector<base::string16> url_list;
+  AppendJavaStringArrayToStringVector(env, urls, &url_list);
+  for (auto url : url_list) {
+    if (!ShouldCapture(GURL(url)))
+      return false;
+  }
+  return true;
+}
+
 }  // namespace content_capture

diff --git a/components/content_capture/android/content_capture_controller.h b/components/content_capture/android/content_capture_controller.h
index 0c9129e..502fca9 100644
--- a/components/content_capture/android/content_capture_controller.h
+++ b/components/content_capture/android/content_capture_controller.h

@@ -35,6 +35,9 @@
                     const base::android::JavaParamRef<jbooleanArray>& jtype);
   void SetJavaPeer(JNIEnv* env,
                    const base::android::JavaParamRef<jobject>& jcaller);
+  bool ShouldCapture(JNIEnv* env,
+                     const base::android::JavaParamRef<jobject>& jcaller,
+                     const base::android::JavaParamRef<jobjectArray>& urls);
 
  private:
   virtual ~ContentCaptureController();

diff --git a/components/content_capture/android/content_capture_features_android.cc b/components/content_capture/android/content_capture_features_android.cc
index 795069e..9258e3e 100644
--- a/components/content_capture/android/content_capture_features_android.cc
+++ b/components/content_capture/android/content_capture_features_android.cc

@@ -8,3 +8,9 @@
 static jboolean JNI_ContentCaptureFeatures_IsEnabled(JNIEnv* env) {
   return content_capture::features::IsContentCaptureEnabled();
 }
+
+static jboolean
+JNI_ContentCaptureFeatures_ShouldTriggerContentCaptureForExperiment(
+    JNIEnv* env) {
+  return content_capture::features::ShouldTriggerContentCaptureForExperiment();
+}

diff --git a/components/content_capture/android/content_capture_receiver_manager_android.cc b/components/content_capture/android/content_capture_receiver_manager_android.cc
index 826a138..364aa7c 100644
--- a/components/content_capture/android/content_capture_receiver_manager_android.cc
+++ b/components/content_capture/android/content_capture_receiver_manager_android.cc

@@ -12,6 +12,7 @@
 #include "components/content_capture/android/content_capture_controller.h"
 #include "components/content_capture/android/jni_headers/ContentCaptureData_jni.h"
 #include "components/content_capture/android/jni_headers/ContentCaptureReceiverManager_jni.h"
+#include "components/content_capture/common/content_capture_features.h"
 #include "content/public/browser/web_contents.h"
 
 using base::android::AttachCurrentThread;
@@ -147,6 +148,11 @@
 }
 
 bool ContentCaptureReceiverManagerAndroid::ShouldCapture(const GURL& url) {
+  // Capture all urls for experiment, the url will be checked
+  // before the content is sent to the consumers.
+  if (features::ShouldTriggerContentCaptureForExperiment())
+    return true;
+
   return ContentCaptureController::Get()->ShouldCapture(url);
 }
 

diff --git a/components/content_capture/android/java/src/org/chromium/components/content_capture/ContentCaptureConsumer.java b/components/content_capture/android/java/src/org/chromium/components/content_capture/ContentCaptureConsumer.java
index a2b4e58..5a8f9e09 100644
--- a/components/content_capture/android/java/src/org/chromium/components/content_capture/ContentCaptureConsumer.java
+++ b/components/content_capture/android/java/src/org/chromium/components/content_capture/ContentCaptureConsumer.java

@@ -50,9 +50,13 @@
         // of the removal of session.
         if (current != null) {
             mManager = ContentCaptureReceiverManager.createOrGet(current);
-            mManager.setContentCaptureConsumer(this);
+            mManager.addContentCaptureConsumer(this);
         } else {
             mManager = null;
         }
     }
+
+    protected boolean shouldCapture(String[] urls) {
+        return true;
+    }
 }

diff --git a/components/content_capture/android/java/src/org/chromium/components/content_capture/ContentCaptureConsumerImpl.java b/components/content_capture/android/java/src/org/chromium/components/content_capture/ContentCaptureConsumerImpl.java
index 280f75b4..9f897464 100644
--- a/components/content_capture/android/java/src/org/chromium/components/content_capture/ContentCaptureConsumerImpl.java
+++ b/components/content_capture/android/java/src/org/chromium/components/content_capture/ContentCaptureConsumerImpl.java

@@ -89,4 +89,14 @@
         new ContentRemovedTask(frame, removedIds, mPlatformSession)
                 .executeOnExecutor(AsyncTask.SERIAL_EXECUTOR);
     }
+
+    @Override
+    protected boolean shouldCapture(String[] urls) {
+        // No need to check if the experiment is disabled, because it was done when the navigation
+        // committed, refer to ContentCaptureReceiverManager::ReadyToCommitNavigation().
+        if (!ContentCaptureFeatures.shouldTriggerContentCaptureForExperiment()) return true;
+        ContentCaptureController controller = ContentCaptureController.getInstance();
+        if (controller == null) return false;
+        return controller.shouldCapture(urls);
+    }
 }

diff --git a/components/content_capture/android/java/src/org/chromium/components/content_capture/ContentCaptureController.java b/components/content_capture/android/java/src/org/chromium/components/content_capture/ContentCaptureController.java
index 5c007e9c..93259117 100644
--- a/components/content_capture/android/java/src/org/chromium/components/content_capture/ContentCaptureController.java
+++ b/components/content_capture/android/java/src/org/chromium/components/content_capture/ContentCaptureController.java

@@ -45,6 +45,15 @@
     public void clearContentCaptureDataForURLs(String[] urlsToDelete) {}
 
     /**
+     * @param urls the urls need to check.
+     * @return if the content of all urls should be captured.
+     */
+    public boolean shouldCapture(String[] urls) {
+        return ContentCaptureControllerJni.get().shouldCapture(
+                mNativeContentCaptureController, ContentCaptureController.this, urls);
+    }
+
+    /**
      * Invoked by native side to pull the allowlist, the subclass should implement this and set
      * the allowlist by call setAllowlist.
      */
@@ -69,5 +78,7 @@
         long init(Object contentCaptureController);
         void setAllowlist(long nativeContentCaptureController, ContentCaptureController caller,
                 String[] allowlist, boolean[] isRegex);
+        boolean shouldCapture(long nativeContentCaptureController, ContentCaptureController caller,
+                String[] urls);
     }
 }

diff --git a/components/content_capture/android/java/src/org/chromium/components/content_capture/ContentCaptureFeatures.java b/components/content_capture/android/java/src/org/chromium/components/content_capture/ContentCaptureFeatures.java
index e1b83e2..1e4624a1 100644
--- a/components/content_capture/android/java/src/org/chromium/components/content_capture/ContentCaptureFeatures.java
+++ b/components/content_capture/android/java/src/org/chromium/components/content_capture/ContentCaptureFeatures.java

@@ -20,8 +20,13 @@
         return CommandLine.getInstance().hasSwitch(FLAG);
     }
 
+    public static boolean shouldTriggerContentCaptureForExperiment() {
+        return ContentCaptureFeaturesJni.get().shouldTriggerContentCaptureForExperiment();
+    }
+
     @NativeMethods
     interface Natives {
         boolean isEnabled();
+        boolean shouldTriggerContentCaptureForExperiment();
     }
 }

diff --git a/components/content_capture/android/java/src/org/chromium/components/content_capture/ContentCaptureReceiverManager.java b/components/content_capture/android/java/src/org/chromium/components/content_capture/ContentCaptureReceiverManager.java
index 4fb015f..045f470 100644
--- a/components/content_capture/android/java/src/org/chromium/components/content_capture/ContentCaptureReceiverManager.java
+++ b/components/content_capture/android/java/src/org/chromium/components/content_capture/ContentCaptureReceiverManager.java

@@ -9,6 +9,7 @@
 import org.chromium.base.annotations.NativeMethods;
 import org.chromium.content_public.browser.WebContents;
 
+import java.util.ArrayList;
 import java.util.Arrays;
 
 /**
@@ -18,7 +19,8 @@
     private static final String TAG = "ContentCapture";
     private static Boolean sDump;
 
-    private ContentCaptureConsumer mContentCaptureConsumer;
+    private ArrayList<ContentCaptureConsumer> mContentCaptureConsumers =
+            new ArrayList<ContentCaptureConsumer>();
 
     public static ContentCaptureReceiverManager createOrGet(WebContents webContents) {
         return ContentCaptureReceiverManagerJni.get().createOrGet(webContents);
@@ -29,22 +31,30 @@
         if (sDump == null) sDump = ContentCaptureFeatures.isDumpForTestingEnabled();
     }
 
-    public void setContentCaptureConsumer(ContentCaptureConsumer consumer) {
-        mContentCaptureConsumer = consumer;
+    public void addContentCaptureConsumer(ContentCaptureConsumer consumer) {
+        mContentCaptureConsumers.add(consumer);
     }
 
     @CalledByNative
     private void didCaptureContent(Object[] session, ContentCaptureData data) {
-        if (mContentCaptureConsumer != null) {
-            mContentCaptureConsumer.onContentCaptured(toFrameSession(session), data);
+        FrameSession frameSession = toFrameSession(session);
+        String[] urls = buildUrls(frameSession, data);
+        for (ContentCaptureConsumer consumer : mContentCaptureConsumers) {
+            if (consumer.shouldCapture(urls)) {
+                consumer.onContentCaptured(frameSession, data);
+            }
         }
         if (sDump.booleanValue()) Log.i(TAG, "Captured Content: %s", data);
     }
 
     @CalledByNative
     private void didUpdateContent(Object[] session, ContentCaptureData data) {
-        if (mContentCaptureConsumer != null) {
-            mContentCaptureConsumer.onContentUpdated(toFrameSession(session), data);
+        FrameSession frameSession = toFrameSession(session);
+        String[] urls = buildUrls(frameSession, data);
+        for (ContentCaptureConsumer consumer : mContentCaptureConsumers) {
+            if (consumer.shouldCapture(urls)) {
+                consumer.onContentUpdated(frameSession, data);
+            }
         }
         if (sDump.booleanValue()) Log.i(TAG, "Updated Content: %s", data);
     }
@@ -52,8 +62,11 @@
     @CalledByNative
     private void didRemoveContent(Object[] session, long[] data) {
         FrameSession frameSession = toFrameSession(session);
-        if (mContentCaptureConsumer != null) {
-            mContentCaptureConsumer.onContentRemoved(frameSession, data);
+        String[] urls = buildUrls(frameSession, null);
+        for (ContentCaptureConsumer consumer : mContentCaptureConsumers) {
+            if (consumer.shouldCapture(urls)) {
+                consumer.onContentRemoved(frameSession, data);
+            }
         }
         if (sDump.booleanValue()) {
             Log.i(TAG, "Removed Content: %s", frameSession.get(0) + " " + Arrays.toString(data));
@@ -63,7 +76,12 @@
     @CalledByNative
     private void didRemoveSession(Object[] session) {
         FrameSession frameSession = toFrameSession(session);
-        if (mContentCaptureConsumer != null) mContentCaptureConsumer.onSessionRemoved(frameSession);
+        String[] urls = buildUrls(frameSession, null);
+        for (ContentCaptureConsumer consumer : mContentCaptureConsumers) {
+            if (consumer.shouldCapture(urls)) {
+                consumer.onSessionRemoved(frameSession);
+            }
+        }
         if (sDump.booleanValue()) Log.i(TAG, "Removed Session: %s", frameSession.get(0));
     }
 
@@ -73,6 +91,19 @@
         return frameSession;
     }
 
+    private String[] buildUrls(FrameSession session, ContentCaptureData data) {
+        ArrayList<String> urls = new ArrayList<String>();
+        if (session != null) {
+            for (ContentCaptureData d : session) {
+                urls.add(d.getValue());
+            }
+        }
+        if (data != null) urls.add(data.getValue());
+        String[] result = new String[urls.size()];
+        urls.toArray(result);
+        return result;
+    }
+
     @NativeMethods
     interface Natives {
         ContentCaptureReceiverManager createOrGet(WebContents webContents);

diff --git a/components/content_capture/android/java/src/org/chromium/components/content_capture/ExperimentContentCaptureConsumer.java b/components/content_capture/android/java/src/org/chromium/components/content_capture/ExperimentContentCaptureConsumer.java
new file mode 100644
index 0000000..9823b56
--- /dev/null
+++ b/components/content_capture/android/java/src/org/chromium/components/content_capture/ExperimentContentCaptureConsumer.java

@@ -0,0 +1,48 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package org.chromium.components.content_capture;
+
+import org.chromium.base.Log;
+import org.chromium.content_public.browser.WebContents;
+
+/**
+ * This class is used to trigger ContentCapture unconditionally for the experiment. It doesn't
+ * consume any content, but is necessary to keep capturing content.
+ */
+public class ExperimentContentCaptureConsumer extends ContentCaptureConsumer {
+    private static final String TAG = "ContentCapture";
+    private static boolean sDump;
+
+    public static ContentCaptureConsumer create(WebContents webContents) {
+        if (ContentCaptureFeatures.shouldTriggerContentCaptureForExperiment()) {
+            return new ExperimentContentCaptureConsumer(webContents);
+        }
+        return null;
+    }
+
+    private ExperimentContentCaptureConsumer(WebContents webContents) {
+        super(webContents);
+    }
+
+    @Override
+    public void onContentCaptured(FrameSession parentFrame, ContentCaptureData contentCaptureData) {
+        if (sDump) Log.d(TAG, "onContentCaptured " + contentCaptureData.toString());
+    }
+
+    @Override
+    public void onSessionRemoved(FrameSession session) {
+        if (sDump) Log.d(TAG, "onSessionRemoved");
+    }
+
+    @Override
+    public void onContentRemoved(FrameSession session, long[] removedIds) {
+        if (sDump) Log.d(TAG, "onContentRemoved");
+    }
+
+    @Override
+    public void onContentUpdated(FrameSession parentFrame, ContentCaptureData contentCaptureData) {
+        if (sDump) Log.d(TAG, "onContentUpdated");
+    }
+}

diff --git a/components/content_capture/common/content_capture_features.cc b/components/content_capture/common/content_capture_features.cc
index 0070ffe5..58832c3 100644
--- a/components/content_capture/common/content_capture_features.cc
+++ b/components/content_capture/common/content_capture_features.cc

@@ -4,6 +4,7 @@
 
 #include "components/content_capture/common/content_capture_features.h"
 
+#include "base/feature_list.h"
 #include "base/metrics/field_trial_params.h"
 #include "build/build_config.h"
 
@@ -13,15 +14,25 @@
 #if defined(OS_ANDROID)
 const base::Feature kContentCapture{"ContentCapture",
                                     base::FEATURE_ENABLED_BY_DEFAULT};
+
+const base::Feature kContentCaptureTriggeringForExperiment{
+    "ContentCaptureTriggeringForExperiment", base::FEATURE_ENABLED_BY_DEFAULT};
 #else
 const base::Feature kContentCapture{"ContentCapture",
                                     base::FEATURE_DISABLED_BY_DEFAULT};
+
+const base::Feature kContentCaptureTriggeringForExperiment{
+    "ContentCaptureTriggeringForExperiment", base::FEATURE_DISABLED_BY_DEFAULT};
 #endif
 
 bool IsContentCaptureEnabled() {
   return base::FeatureList::IsEnabled(kContentCapture);
 }
 
+bool ShouldTriggerContentCaptureForExperiment() {
+  return base::FeatureList::IsEnabled(kContentCaptureTriggeringForExperiment);
+}
+
 int TaskLongDelayInMilliseconds() {
   return base::GetFieldTrialParamByFeatureAsInt(
       kContentCapture, "task_long_delay_in_milliseconds", 5000);

diff --git a/components/content_capture/common/content_capture_features.h b/components/content_capture/common/content_capture_features.h
index f9c09ee..6d598e0 100644
--- a/components/content_capture/common/content_capture_features.h
+++ b/components/content_capture/common/content_capture_features.h

@@ -13,7 +13,13 @@
 
 extern const base::Feature kContentCaptureEnabled;
 
+// ContentCapture is triggered in the unpredictable conditions which might be
+// changed on different aiai release or configuration push, this feature allows
+// us to trigger the ContentCapture independently to get the unbiased result.
+extern const base::Feature kContentCaptureTriggeringForExperiment;
+
 bool IsContentCaptureEnabled();
+bool ShouldTriggerContentCaptureForExperiment();
 
 int TaskLongDelayInMilliseconds();
 int TaskShortDelayInMilliseconds();

diff --git a/components/download/internal/common/download_response_handler.cc b/components/download/internal/common/download_response_handler.cc
index 35a066f..5987f85 100644
--- a/components/download/internal/common/download_response_handler.cc
+++ b/components/download/internal/common/download_response_handler.cc

@@ -243,16 +243,6 @@
         ConvertInterruptReasonToMojoNetworkRequestStatus(reason));
   }
 
-  if (reason == DOWNLOAD_INTERRUPT_REASON_NETWORK_FAILED) {
-    base::UmaHistogramSparse("Download.MapErrorNetworkFailed.NetworkService",
-                             std::abs(status.error_code));
-    if (is_background_mode_) {
-      base::UmaHistogramSparse(
-          "Download.MapErrorNetworkFailed.NetworkService.BackgroundDownload",
-          std::abs(status.error_code));
-    }
-  }
-
   if (started_) {
     delegate_->OnResponseCompleted();
     return;

diff --git a/components/exo/data_device.h b/components/exo/data_device.h
index bd6d23210..73ad1a2 100644
--- a/components/exo/data_device.h
+++ b/components/exo/data_device.h

@@ -8,6 +8,7 @@
 #include <cstdint>
 
 #include "base/macros.h"
+#include "build/build_config.h"
 #include "components/exo/data_offer_observer.h"
 #include "components/exo/seat_observer.h"
 #include "components/exo/surface.h"
@@ -66,6 +67,9 @@
 
   // Overridden from ui::ClipboardObserver:
   void OnClipboardDataChanged() override;
+#if defined(OS_CHROMEOS)
+  void OnClipboardDataRead() override {}
+#endif
 
   // Overridden from SeatObserver:
   void OnSurfaceFocusing(Surface* surface) override;

diff --git a/components/exo/seat.h b/components/exo/seat.h
index b9d9f06b..9f99c2e 100644
--- a/components/exo/seat.h
+++ b/components/exo/seat.h

@@ -8,6 +8,7 @@
 #include "base/containers/flat_map.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
+#include "build/build_config.h"
 #include "components/exo/data_source_observer.h"
 #include "ui/aura/client/drag_drop_delegate.h"
 #include "ui/aura/client/focus_change_observer.h"
@@ -92,6 +93,9 @@
 
   // Overridden from ui::ClipboardObserver:
   void OnClipboardDataChanged() override;
+#if defined(OS_CHROMEOS)
+  void OnClipboardDataRead() override {}
+#endif  // defined(OS_CHROMEOS)
 
   // Overridden from DataSourceObserver:
   void OnDataSourceDestroying(DataSource* source) override;

diff --git a/components/open_from_clipboard/clipboard_recent_content_impl_ios.mm b/components/open_from_clipboard/clipboard_recent_content_impl_ios.mm
index 5a6927ab..6acecec 100644
--- a/components/open_from_clipboard/clipboard_recent_content_impl_ios.mm
+++ b/components/open_from_clipboard/clipboard_recent_content_impl_ios.mm

@@ -8,6 +8,7 @@
 #import <UIKit/UIKit.h>
 
 #import "base/mac/foundation_util.h"
+#include "base/notreached.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/system/sys_info.h"
 
@@ -74,6 +75,23 @@
 // Returns whether the value of the clipboard should be returned.
 - (BOOL)shouldReturnValueOfClipboard;
 
+// Calls |completionHandler| with the result of whether or not the clipboard
+// currently contains data matching |contentType|.
+- (void)checkForContentType:(ContentType)contentType
+          completionHandler:(void (^)(BOOL))completionHandler;
+
+// Checks the clipboard for content matching |types| and calls
+// |completionHandler| once all types are checked. This method is called
+// recursively and partial results are passed in |results| until all types have
+// been checked.
+- (void)
+    hasContentMatchingRemainingTypes:(NSSet<ContentType>*)types
+                             results:
+                                 (NSMutableDictionary<ContentType, NSNumber*>*)
+                                     results
+                   completionHandler:
+                       (void (^)(NSSet<ContentType>*))completionHandler;
+
 @end
 
 @implementation ClipboardRecentContentImplIOS
@@ -181,45 +199,64 @@
               completionHandler:
                   (void (^)(NSSet<ContentType>*))completionHandler {
   [self updateIfNeeded];
-  if (![self shouldReturnValueOfClipboard]) {
+  if (![self shouldReturnValueOfClipboard] || ![types count]) {
     completionHandler([NSSet set]);
     return;
   }
 
-  __block NSMutableDictionary<ContentType, NSNumber*>* results =
-      [[NSMutableDictionary alloc] init];
+  [self hasContentMatchingRemainingTypes:types
+                                 results:[[NSMutableDictionary alloc] init]
+                       completionHandler:completionHandler];
+}
 
-  void (^checkResults)() = ^{
+- (void)
+    hasContentMatchingRemainingTypes:(NSSet<ContentType>*)types
+                             results:
+                                 (NSMutableDictionary<ContentType, NSNumber*>*)
+                                     results
+                   completionHandler:
+                       (void (^)(NSSet<ContentType>*))completionHandler {
+  if ([types count] == 0) {
     NSMutableSet<ContentType>* matchingTypes = [NSMutableSet set];
-    if ([results count] != [types count]) {
-      return;
-    }
-
     for (ContentType type in results) {
       if ([results[type] boolValue]) {
         [matchingTypes addObject:type];
       }
     }
     completionHandler(matchingTypes);
-  };
+    return;
+  }
 
-  for (ContentType type in types) {
-    if ([type isEqualToString:ContentTypeURL]) {
-      [self hasRecentURLFromClipboardInternal:^(BOOL hasURL) {
-        results[ContentTypeURL] = [NSNumber numberWithBool:hasURL];
-        checkResults();
-      }];
-    } else if ([type isEqualToString:ContentTypeText]) {
-      [self hasRecentTextFromClipboardInternal:^(BOOL hasText) {
-        results[ContentTypeText] = [NSNumber numberWithBool:hasText];
-        checkResults();
-      }];
-    } else if ([type isEqualToString:ContentTypeImage]) {
-      [self hasRecentImageFromClipboardInternal:^(BOOL hasImage) {
-        results[ContentTypeImage] = [NSNumber numberWithBool:hasImage];
-        checkResults();
-      }];
-    }
+  __weak __typeof(self) weakSelf = self;
+  ContentType type = [types anyObject];
+  [self checkForContentType:type
+          completionHandler:^(BOOL hasType) {
+            results[type] = @(hasType);
+
+            NSMutableSet* remainingTypes = [types mutableCopy];
+            [remainingTypes removeObject:type];
+            [weakSelf hasContentMatchingRemainingTypes:remainingTypes
+                                               results:results
+                                     completionHandler:completionHandler];
+          }];
+}
+
+- (void)checkForContentType:(ContentType)contentType
+          completionHandler:(void (^)(BOOL))completionHandler {
+  if ([contentType isEqualToString:ContentTypeText]) {
+    [self hasRecentTextFromClipboardInternal:^(BOOL hasText) {
+      completionHandler(hasText);
+    }];
+  } else if ([contentType isEqualToString:ContentTypeURL]) {
+    [self hasRecentURLFromClipboardInternal:^(BOOL hasURL) {
+      completionHandler(hasURL);
+    }];
+  } else if ([contentType isEqualToString:ContentTypeImage]) {
+    [self hasRecentImageFromClipboardInternal:^(BOOL hasImage) {
+      completionHandler(hasImage);
+    }];
+  } else {
+    NOTREACHED() << contentType;
   }
 }
 
@@ -325,6 +362,8 @@
               completionHandler:^(
                   NSDictionary<UIPasteboardDetectionPattern, id>* values,
                   NSError* error) {
+                DCHECK(!error) << error.debugDescription;
+
                 NSURL* url = [NSURL
                     URLWithString:
                         values[UIPasteboardDetectionPatternProbableWebURL]];

diff --git a/components/viz/service/display/gl_renderer_unittest.cc b/components/viz/service/display/gl_renderer_unittest.cc
index 3252da36..8ff3685 100644
--- a/components/viz/service/display/gl_renderer_unittest.cc
+++ b/components/viz/service/display/gl_renderer_unittest.cc

@@ -184,8 +184,7 @@
       const DirectRenderer::DrawingFrame& drawing_frame,
       bool validate_output_color_matrix) {
     renderer()->SetCurrentFrameForTesting(drawing_frame);
-    const size_t kNumSrcColorSpaces = 8;
-    gfx::ColorSpace src_color_spaces[kNumSrcColorSpaces] = {
+    const gfx::ColorSpace kSrcColorSpaces[] = {
         gfx::ColorSpace::CreateSRGB(),
         gfx::ColorSpace(gfx::ColorSpace::PrimaryID::ADOBE_RGB,
                         gfx::ColorSpace::TransferID::GAMMA28),
@@ -202,45 +201,43 @@
         // This won't be, because it has a set SDR white level.
         gfx::ColorSpace::CreateHDR10(123.0f),
     };
-    const size_t kNumDstColorSpaces = 4;
-    gfx::ColorSpace dst_color_spaces[kNumDstColorSpaces] = {
+    const gfx::ColorSpace kDstColorSpaces[] = {
         gfx::ColorSpace::CreateSRGB(),
         gfx::ColorSpace(gfx::ColorSpace::PrimaryID::ADOBE_RGB,
                         gfx::ColorSpace::TransferID::GAMMA18),
         gfx::ColorSpace::CreateExtendedSRGB(),
         gfx::ColorSpace::CreateSCRGBLinear(),
     };
-    for (size_t i = 0; i < kNumDstColorSpaces; ++i) {
-      for (size_t j = 0; j < kNumSrcColorSpaces; ++j) {
-        const auto& src_color_space = src_color_spaces[j];
-        const auto& dst_color_space = dst_color_spaces[i];
-
+    // Note: Use ASSERT_XXX() and not EXPECT_XXX() below since the size of the
+    // loop will lead to useless timeout failures on the bots otherwise.
+    for (const auto& src_color_space : kSrcColorSpaces) {
+      for (const auto& dst_color_space : kDstColorSpaces) {
         renderer()->SetUseProgram(program_key, src_color_space, dst_color_space,
                                   /*adjust_src_white_level=*/true);
-        EXPECT_TRUE(renderer()->current_program_->initialized());
+        ASSERT_TRUE(renderer()->current_program_->initialized());
 
         if (src_color_space != dst_color_space) {
           auto adjusted_color_space = src_color_space;
-          // Only in the iteration where we use an HDR color space without
-          // specifying an SDR white level should the white level be set by the
-          // renderer.
-          if (src_color_space == gfx::ColorSpace::CreateSCRGBLinear() ||
-              src_color_space == gfx::ColorSpace::CreateHDR10()) {
+          if (src_color_space.IsHDR()) {
             adjusted_color_space = src_color_space.GetWithSDRWhiteLevel(
                 drawing_frame.display_color_spaces.GetSDRWhiteLevel());
-            EXPECT_NE(adjusted_color_space, src_color_space);
           }
+          SCOPED_TRACE(
+              base::StringPrintf("adjusted_color_space=%s, dst_color_space=%s",
+                                 adjusted_color_space.ToString().c_str(),
+                                 dst_color_space.ToString().c_str()));
+
           auto color_transform = gfx::ColorTransform::NewColorTransform(
               adjusted_color_space, dst_color_space,
               gfx::ColorTransform::Intent::INTENT_PERCEPTUAL);
-          EXPECT_EQ(color_transform->GetShaderSource(),
+          ASSERT_EQ(color_transform->GetShaderSource(),
                     renderer()
                         ->current_program_->color_transform_for_testing()
                         ->GetShaderSource());
         }
 
         if (validate_output_color_matrix) {
-          EXPECT_NE(
+          ASSERT_NE(
               -1, renderer()->current_program_->output_color_matrix_location());
         }
       }

diff --git a/content/browser/frame_host/render_frame_host_delegate.h b/content/browser/frame_host/render_frame_host_delegate.h
index 30c06a6..c934841 100644
--- a/content/browser/frame_host/render_frame_host_delegate.h
+++ b/content/browser/frame_host/render_frame_host_delegate.h

@@ -79,6 +79,7 @@
 }
 
 namespace content {
+class AgentSchedulingGroupHost;
 class FrameTreeNode;
 class PageState;
 class RenderFrameHostImpl;
@@ -562,20 +563,20 @@
   virtual bool HasSeenRecentScreenOrientationChange();
 
   // The page is trying to open a new widget (e.g. a select popup). The
-  // widget should be created associated with the given |widget_route_id| in the
-  // process |render_process_id|, but it should not be shown yet. That should
+  // widget should be created associated with the given
+  // |agent_scheduling_group|, but it should not be shown yet. That should
   // happen in response to ShowCreatedWidget.
   virtual void CreateNewWidget(
-      int32_t render_process_id,
-      int32_t widget_route_id,
+      AgentSchedulingGroupHost& agent_scheduling_group,
+      int32_t route_id,
       mojo::PendingAssociatedReceiver<blink::mojom::WidgetHost>
           blink_widget_host,
       mojo::PendingAssociatedRemote<blink::mojom::Widget> blink_widget) {}
 
   // Creates a full screen RenderWidget. Similar to above.
   virtual void CreateNewFullscreenWidget(
-      int32_t render_process_id,
-      int32_t widget_route_id,
+      AgentSchedulingGroupHost& agent_scheduling_group,
+      int32_t route_id,
       mojo::PendingAssociatedReceiver<blink::mojom::WidgetHost>
           blink_widget_host,
       mojo::PendingAssociatedRemote<blink::mojom::Widget> blink_widget) {}

diff --git a/content/browser/frame_host/render_frame_host_impl.cc b/content/browser/frame_host/render_frame_host_impl.cc
index 5b2ce6aa..7836afd 100644
--- a/content/browser/frame_host/render_frame_host_impl.cc
+++ b/content/browser/frame_host/render_frame_host_impl.cc

@@ -1011,7 +1011,7 @@
           site_instance->GetProcess()->GetNextRoutingID();
       DCHECK_EQ(nullptr, GetLocalRenderWidgetHost());
       owned_render_widget_host_ = RenderWidgetHostFactory::Create(
-          frame_tree_->render_widget_delegate(), GetProcess(),
+          frame_tree_->render_widget_delegate(), agent_scheduling_group_,
           widget_routing_id, /*hidden=*/true);
       owned_render_widget_host_->set_owned_by_render_frame_host(true);
 #if defined(OS_ANDROID)
@@ -5199,7 +5199,7 @@
     CreateNewWidgetCallback callback) {
   int32_t widget_route_id = GetProcess()->GetNextRoutingID();
   std::move(callback).Run(widget_route_id);
-  delegate_->CreateNewWidget(GetProcess()->GetID(), widget_route_id,
+  delegate_->CreateNewWidget(agent_scheduling_group_, widget_route_id,
                              std::move(blink_widget_host),
                              std::move(blink_widget));
 }
@@ -5210,7 +5210,7 @@
     CreateNewFullscreenWidgetCallback callback) {
   int32_t widget_route_id = GetProcess()->GetNextRoutingID();
   std::move(callback).Run(widget_route_id);
-  delegate_->CreateNewFullscreenWidget(GetProcess()->GetID(), widget_route_id,
+  delegate_->CreateNewFullscreenWidget(agent_scheduling_group_, widget_route_id,
                                        std::move(blink_widget_host),
                                        std::move(blink_widget));
 }

diff --git a/content/browser/renderer_host/agent_scheduling_group_host.cc b/content/browser/renderer_host/agent_scheduling_group_host.cc
index 0f522fb..c64a333 100644
--- a/content/browser/renderer_host/agent_scheduling_group_host.cc
+++ b/content/browser/renderer_host/agent_scheduling_group_host.cc

@@ -7,6 +7,7 @@
 
 #include "base/supports_user_data.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
+#include "content/common/renderer.mojom.h"
 #include "content/public/browser/render_process_host.h"
 
 namespace content {
@@ -20,6 +21,7 @@
 
 static constexpr char kAgentGroupHostDataKey[] =
     "AgentSchedulingGroupHostUserDataKey";
+
 class AgentGroupHostUserData : public base::SupportsUserData::Data {
  public:
   explicit AgentGroupHostUserData(
@@ -54,8 +56,12 @@
 }
 
 AgentSchedulingGroupHost::AgentSchedulingGroupHost(RenderProcessHost& process)
-    : process_(process) {}
+    : process_(process) {
+  process_.GetRendererInterface()->CreateAgentSchedulingGroup();
+}
 
+// DO NOT USE |process_| HERE! At this point it (or at least parts of it) is no
+// longer valid.
 AgentSchedulingGroupHost::~AgentSchedulingGroupHost() = default;
 
 RenderProcessHost* AgentSchedulingGroupHost::GetProcess() {

diff --git a/content/browser/renderer_host/cursor_manager_unittest.cc b/content/browser/renderer_host/cursor_manager_unittest.cc
index 79b9e2df..f52675d 100644
--- a/content/browser/renderer_host/cursor_manager_unittest.cc
+++ b/content/browser/renderer_host/cursor_manager_unittest.cc

@@ -3,8 +3,10 @@
 // found in the LICENSE file.
 
 #include "content/browser/renderer_host/cursor_manager.h"
+#include <memory>
 
 #include "build/build_config.h"
+#include "content/browser/renderer_host/agent_scheduling_group_host.h"
 #include "content/browser/renderer_host/mock_render_widget_host.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/common/cursors/webcursor.h"
@@ -28,7 +30,7 @@
   MockRenderWidgetHostViewForCursors(RenderWidgetHost* host, bool top_view)
       : TestRenderWidgetHostView(host) {
     if (top_view)
-      cursor_manager_.reset(new CursorManager(this));
+      cursor_manager_ = std::make_unique<CursorManager>(this);
   }
 
   void DisplayCursor(const WebCursor& cursor) override {
@@ -46,11 +48,14 @@
 
 class CursorManagerTest : public testing::Test {
  public:
-  CursorManagerTest() {}
+  CursorManagerTest() = default;
 
   void SetUp() override {
-    browser_context_.reset(new TestBrowserContext);
-    process_host_.reset(new MockRenderProcessHost(browser_context_.get()));
+    browser_context_ = std::make_unique<TestBrowserContext>();
+    process_host_ =
+        std::make_unique<MockRenderProcessHost>(browser_context_.get());
+    agent_scheduling_group_host_ =
+        std::make_unique<AgentSchedulingGroupHost>(*process_host_);
     widget_host_.reset(MakeNewWidgetHost());
     top_view_ =
         new MockRenderWidgetHostViewForCursors(widget_host_.get(), true);
@@ -58,16 +63,17 @@
 
   RenderWidgetHostImpl* MakeNewWidgetHost() {
     int32_t routing_id = process_host_->GetNextRoutingID();
-    return MockRenderWidgetHost::Create(&delegate_, process_host_.get(),
-                                        routing_id);
+    return MockRenderWidgetHost::Create(
+        &delegate_, *agent_scheduling_group_host_, routing_id);
   }
 
   void TearDown() override {
     if (top_view_)
       delete top_view_;
 
-    widget_host_.reset();
-    process_host_.reset();
+    widget_host_ = nullptr;
+    agent_scheduling_group_host_ = nullptr;
+    process_host_ = nullptr;
   }
 
  protected:
@@ -75,6 +81,7 @@
 
   std::unique_ptr<BrowserContext> browser_context_;
   std::unique_ptr<MockRenderProcessHost> process_host_;
+  std::unique_ptr<AgentSchedulingGroupHost> agent_scheduling_group_host_;
   std::unique_ptr<RenderWidgetHostImpl> widget_host_;
 
   // Tests should set this to nullptr if they've already triggered its

diff --git a/content/browser/renderer_host/input/fling_scheduler_unittest.cc b/content/browser/renderer_host/input/fling_scheduler_unittest.cc
index 2c608ac..c9b74cf 100644
--- a/content/browser/renderer_host/input/fling_scheduler_unittest.cc
+++ b/content/browser/renderer_host/input/fling_scheduler_unittest.cc

@@ -5,6 +5,7 @@
 #include "content/browser/renderer_host/input/fling_scheduler.h"
 
 #include "build/build_config.h"
+#include "content/browser/renderer_host/agent_scheduling_group_host.h"
 #include "content/public/test/browser_task_environment.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "content/public/test/test_browser_context.h"
@@ -75,11 +76,14 @@
     browser_context_ = std::make_unique<TestBrowserContext>();
     process_host_ = new MockRenderProcessHost(browser_context_.get());
     process_host_->Init();
+    agent_scheduling_group_host_ =
+        std::make_unique<AgentSchedulingGroupHost>(*process_host_);
     int32_t routing_id = process_host_->GetNextRoutingID();
     delegate_ = std::make_unique<MockRenderWidgetHostDelegate>();
-    widget_host_ = TestRenderWidgetHost::Create(delegate_.get(), process_host_,
-                                                routing_id, false)
-                       .release();
+    widget_host_ =
+        TestRenderWidgetHost::Create(
+            delegate_.get(), *agent_scheduling_group_host_, routing_id, false)
+            .release();
     delegate_->set_widget_host(widget_host_);
     return new TestRenderWidgetHostView(widget_host_);
   }
@@ -122,6 +126,7 @@
   std::unique_ptr<TestBrowserContext> browser_context_;
   RenderWidgetHostImpl* widget_host_;
   MockRenderProcessHost* process_host_;
+  std::unique_ptr<AgentSchedulingGroupHost> agent_scheduling_group_host_;
   TestRenderWidgetHostView* view_;
   std::unique_ptr<MockRenderWidgetHostDelegate> delegate_;
 #if defined(OS_WIN)

diff --git a/content/browser/renderer_host/input/mouse_latency_browsertest.cc b/content/browser/renderer_host/input/mouse_latency_browsertest.cc
index d134d4d7..faa81629 100644
--- a/content/browser/renderer_host/input/mouse_latency_browsertest.cc
+++ b/content/browser/renderer_host/input/mouse_latency_browsertest.cc

@@ -19,6 +19,7 @@
 #include "content/browser/renderer_host/input/synthetic_tap_gesture.h"
 #include "content/browser/renderer_host/render_widget_host_factory.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
+#include "content/browser/site_instance_impl.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/common/input/synthetic_gesture_params.h"
 #include "content/public/browser/render_view_host.h"
@@ -76,15 +77,14 @@
 class TracingRenderWidgetHost : public RenderWidgetHostImpl {
  public:
   TracingRenderWidgetHost(RenderWidgetHostDelegate* delegate,
-                          RenderProcessHost* process,
+                          AgentSchedulingGroupHost& agent_scheduling_group,
                           int32_t routing_id,
                           bool hidden)
       : RenderWidgetHostImpl(delegate,
-                             process,
+                             agent_scheduling_group,
                              routing_id,
                              hidden,
-                             std::make_unique<FrameTokenMessageQueue>()) {
-  }
+                             std::make_unique<FrameTokenMessageQueue>()) {}
 
   void OnMouseEventAck(
       const MouseEventWithLatencyInfo& event,
@@ -108,11 +108,11 @@
 
   std::unique_ptr<RenderWidgetHostImpl> CreateRenderWidgetHost(
       RenderWidgetHostDelegate* delegate,
-      RenderProcessHost* process,
+      AgentSchedulingGroupHost& agent_scheduling_group,
       int32_t routing_id,
       bool hidden) override {
-    return std::make_unique<TracingRenderWidgetHost>(delegate, process,
-                                                     routing_id, hidden);
+    return std::make_unique<TracingRenderWidgetHost>(
+        delegate, agent_scheduling_group, routing_id, hidden);
   }
 
  private:

diff --git a/content/browser/renderer_host/mock_render_widget_host.cc b/content/browser/renderer_host/mock_render_widget_host.cc
index cd0b249..0441b9c2 100644
--- a/content/browser/renderer_host/mock_render_widget_host.cc
+++ b/content/browser/renderer_host/mock_render_widget_host.cc

@@ -40,22 +40,22 @@
 // static
 MockRenderWidgetHost* MockRenderWidgetHost::Create(
     RenderWidgetHostDelegate* delegate,
-    RenderProcessHost* process,
+    AgentSchedulingGroupHost& agent_scheduling_group,
     int32_t routing_id) {
   mojo::AssociatedRemote<blink::mojom::Widget> blink_widget;
   auto blink_widget_receiver =
       blink_widget.BindNewEndpointAndPassDedicatedReceiverForTesting();
-  return new MockRenderWidgetHost(delegate, process, routing_id,
+  return new MockRenderWidgetHost(delegate, agent_scheduling_group, routing_id,
                                   blink_widget.Unbind());
 }
 
 MockRenderWidgetHost* MockRenderWidgetHost::Create(
     RenderWidgetHostDelegate* delegate,
-    RenderProcessHost* process,
+    AgentSchedulingGroupHost& agent_scheduling_group,
     int32_t routing_id,
     mojo::PendingAssociatedRemote<blink::mojom::Widget> pending_blink_widget) {
   DCHECK(pending_blink_widget);
-  return new MockRenderWidgetHost(delegate, process, routing_id,
+  return new MockRenderWidgetHost(delegate, agent_scheduling_group, routing_id,
                                   std::move(pending_blink_widget));
 }
 
@@ -70,11 +70,11 @@
 
 MockRenderWidgetHost::MockRenderWidgetHost(
     RenderWidgetHostDelegate* delegate,
-    RenderProcessHost* process,
+    AgentSchedulingGroupHost& agent_scheduling_group,
     int routing_id,
     mojo::PendingAssociatedRemote<blink::mojom::Widget> pending_blink_widget)
     : RenderWidgetHostImpl(delegate,
-                           process,
+                           agent_scheduling_group,
                            routing_id,
                            /*hidden=*/false,
                            std::make_unique<FrameTokenMessageQueue>()),

diff --git a/content/browser/renderer_host/mock_render_widget_host.h b/content/browser/renderer_host/mock_render_widget_host.h
index c0ac15d..63c7d232 100644
--- a/content/browser/renderer_host/mock_render_widget_host.h
+++ b/content/browser/renderer_host/mock_render_widget_host.h

@@ -58,13 +58,14 @@
 
   InputRouter* input_router() { return input_router_.get(); }
 
-  static MockRenderWidgetHost* Create(RenderWidgetHostDelegate* delegate,
-                                      RenderProcessHost* process,
-                                      int32_t routing_id);
+  static MockRenderWidgetHost* Create(
+      RenderWidgetHostDelegate* delegate,
+      AgentSchedulingGroupHost& agent_scheduling_group,
+      int32_t routing_id);
 
   static MockRenderWidgetHost* Create(
       RenderWidgetHostDelegate* delegate,
-      RenderProcessHost* process,
+      AgentSchedulingGroupHost& agent_scheduling_group,
       int32_t routing_id,
       mojo::PendingAssociatedRemote<blink::mojom::Widget> pending_blink_widget);
 
@@ -81,7 +82,7 @@
  private:
   MockRenderWidgetHost(
       RenderWidgetHostDelegate* delegate,
-      RenderProcessHost* process,
+      AgentSchedulingGroupHost& agent_scheduling_group,
       int32_t routing_id,
       mojo::PendingAssociatedRemote<blink::mojom::Widget> pending_blink_widget);
 

diff --git a/content/browser/renderer_host/render_view_host_factory.cc b/content/browser/renderer_host/render_view_host_factory.cc
index 1db0c39..6765235 100644
--- a/content/browser/renderer_host/render_view_host_factory.cc
+++ b/content/browser/renderer_host/render_view_host_factory.cc

@@ -10,6 +10,7 @@
 #include "base/memory/ptr_util.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_factory.h"
+#include "content/browser/site_instance_impl.h"
 #include "mojo/public/cpp/bindings/pending_remote.h"
 
 namespace content {
@@ -37,9 +38,11 @@
 
   RenderViewHostImpl* view_host = new RenderViewHostImpl(
       instance,
-      RenderWidgetHostFactory::Create(widget_delegate, instance->GetProcess(),
-                                      widget_routing_id,
-                                      /*hidden=*/true),
+      RenderWidgetHostFactory::Create(
+          widget_delegate,
+          static_cast<SiteInstanceImpl*>(instance)->GetAgentSchedulingGroup(),
+          widget_routing_id,
+          /*hidden=*/true),
       delegate, routing_id, main_frame_routing_id, swapped_out,
       true /* has_initialized_audio_host */);
   return view_host;

diff --git a/content/browser/renderer_host/render_widget_host_factory.cc b/content/browser/renderer_host/render_widget_host_factory.cc
index c1c1476..3c7dfe5 100644
--- a/content/browser/renderer_host/render_widget_host_factory.cc
+++ b/content/browser/renderer_host/render_widget_host_factory.cc

@@ -15,15 +15,15 @@
 // static
 std::unique_ptr<RenderWidgetHostImpl> RenderWidgetHostFactory::Create(
     RenderWidgetHostDelegate* delegate,
-    RenderProcessHost* process,
+    AgentSchedulingGroupHost& agent_scheduling_group,
     int32_t routing_id,
     bool hidden) {
   if (factory_) {
-    return factory_->CreateRenderWidgetHost(delegate, process, routing_id,
-                                            hidden);
+    return factory_->CreateRenderWidgetHost(delegate, agent_scheduling_group,
+                                            routing_id, hidden);
   }
   return std::make_unique<RenderWidgetHostImpl>(
-      delegate, process, routing_id, hidden,
+      delegate, agent_scheduling_group, routing_id, hidden,
       std::make_unique<FrameTokenMessageQueue>());
 }
 

diff --git a/content/browser/renderer_host/render_widget_host_factory.h b/content/browser/renderer_host/render_widget_host_factory.h
index 3e263d6..770615b 100644
--- a/content/browser/renderer_host/render_widget_host_factory.h
+++ b/content/browser/renderer_host/render_widget_host_factory.h

@@ -13,7 +13,7 @@
 #include "mojo/public/cpp/bindings/pending_remote.h"
 
 namespace content {
-class RenderProcessHost;
+class AgentSchedulingGroupHost;
 class RenderWidgetHostDelegate;
 class RenderWidgetHostImpl;
 
@@ -27,7 +27,7 @@
   // pointer will be passed to the caller.
   static std::unique_ptr<RenderWidgetHostImpl> Create(
       RenderWidgetHostDelegate* delegate,
-      RenderProcessHost* process,
+      AgentSchedulingGroupHost& agent_scheduling_group,
       int32_t routing_id,
       bool hidden);
 
@@ -35,14 +35,14 @@
   static bool has_factory() { return !!factory_; }
 
  protected:
-  RenderWidgetHostFactory() {}
-  virtual ~RenderWidgetHostFactory() {}
+  RenderWidgetHostFactory() = default;
+  virtual ~RenderWidgetHostFactory() = default;
 
   // You can derive from this class and specify an implementation for this
   // function to create a different kind of RenderWidgetHostImpl for testing.
   virtual std::unique_ptr<RenderWidgetHostImpl> CreateRenderWidgetHost(
       RenderWidgetHostDelegate* delegate,
-      RenderProcessHost* process,
+      AgentSchedulingGroupHost& agent_scheduling_group,
       int32_t routing_id,
       bool hidden) = 0;
 

diff --git a/content/browser/renderer_host/render_widget_host_impl.cc b/content/browser/renderer_host/render_widget_host_impl.cc
index 9c56fad..ae13996e 100644
--- a/content/browser/renderer_host/render_widget_host_impl.cc
+++ b/content/browser/renderer_host/render_widget_host_impl.cc

@@ -48,6 +48,7 @@
 #include "content/browser/file_system/browser_file_system_helper.h"
 #include "content/browser/gpu/compositor_util.h"
 #include "content/browser/native_file_system/native_file_system_manager_impl.h"
+#include "content/browser/renderer_host/agent_scheduling_group_host.h"
 #include "content/browser/renderer_host/dip_util.h"
 #include "content/browser/renderer_host/display_feature.h"
 #include "content/browser/renderer_host/display_util.h"
@@ -176,15 +177,12 @@
 // iteration (or NULL if there isn't any left).
 class RenderWidgetHostIteratorImpl : public RenderWidgetHostIterator {
  public:
-  RenderWidgetHostIteratorImpl()
-      : current_index_(0) {
-  }
-
-  ~RenderWidgetHostIteratorImpl() override {}
+  RenderWidgetHostIteratorImpl() = default;
+  ~RenderWidgetHostIteratorImpl() override = default;
 
   void Add(RenderWidgetHost* host) {
-    hosts_.push_back(RenderWidgetHostID(host->GetProcess()->GetID(),
-                                        host->GetRoutingID()));
+    hosts_.push_back(
+        RenderWidgetHostID(host->GetProcess()->GetID(), host->GetRoutingID()));
   }
 
   // RenderWidgetHostIterator:
@@ -200,7 +198,7 @@
 
  private:
   std::vector<RenderWidgetHostID> hosts_;
-  size_t current_index_;
+  size_t current_index_ = 0;
 
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostIteratorImpl);
 };
@@ -391,12 +389,12 @@
 
 RenderWidgetHostImpl::RenderWidgetHostImpl(
     RenderWidgetHostDelegate* delegate,
-    RenderProcessHost* process,
+    AgentSchedulingGroupHost& agent_scheduling_group,
     int32_t routing_id,
     bool hidden,
     std::unique_ptr<FrameTokenMessageQueue> frame_token_message_queue)
     : delegate_(delegate),
-      process_(process),
+      agent_scheduling_group_(agent_scheduling_group),
       routing_id_(routing_id),
       clock_(base::DefaultTickClock::GetInstance()),
       is_hidden_(hidden),
@@ -411,7 +409,8 @@
           base::ThreadTaskRunnerHandle::Get(),
 #endif
           frame_token_message_queue_.get()),
-      frame_sink_id_(base::checked_cast<uint32_t>(process_->GetID()),
+      frame_sink_id_(base::checked_cast<uint32_t>(
+                         agent_scheduling_group.GetProcess()->GetID()),
                      base::checked_cast<uint32_t>(routing_id_)) {
   DCHECK(frame_token_message_queue_);
   frame_token_message_queue_->Init(this);
@@ -430,15 +429,18 @@
 
   std::pair<RoutingIDWidgetMap::iterator, bool> result =
       g_routing_id_widget_map.Get().insert(std::make_pair(
-          RenderWidgetHostID(process->GetID(), routing_id_), this));
+          RenderWidgetHostID(agent_scheduling_group.GetProcess()->GetID(),
+                             routing_id_),
+          this));
   CHECK(result.second) << "Inserting a duplicate item!";
-  process_->AddRoute(routing_id_, this);
-  process_->AddObserver(this);
+  agent_scheduling_group_.AddRoute(routing_id_, this);
+  agent_scheduling_group.GetProcess()->AddObserver(this);
   render_process_blocked_state_changed_subscription_ =
-      process_->RegisterBlockStateChangedCallback(base::BindRepeating(
-          &RenderWidgetHostImpl::RenderProcessBlockedStateChanged,
-          base::Unretained(this)));
-  process_->AddPriorityClient(this);
+      agent_scheduling_group.GetProcess()->RegisterBlockStateChangedCallback(
+          base::BindRepeating(
+              &RenderWidgetHostImpl::RenderProcessBlockedStateChanged,
+              base::Unretained(this)));
+  agent_scheduling_group.GetProcess()->AddPriorityClient(this);
 
   SetupInputRouter();
 
@@ -531,7 +533,7 @@
     base::TimeDelta::FromMilliseconds(300);
 
 RenderProcessHost* RenderWidgetHostImpl::GetProcess() {
-  return process_;
+  return agent_scheduling_group_.GetProcess();
 }
 
 int RenderWidgetHostImpl::GetRoutingID() {
@@ -587,11 +589,11 @@
 
 void RenderWidgetHostImpl::UpdatePriority() {
   if (!destroyed_)
-    process_->UpdateClientPriority(this);
+    GetProcess()->UpdateClientPriority(this);
 }
 
 void RenderWidgetHostImpl::Init() {
-  DCHECK(process_->IsInitializedAndNotDead());
+  DCHECK(GetProcess()->IsInitializedAndNotDead());
 
   set_renderer_initialized(true);
 
@@ -668,7 +670,7 @@
 }
 
 void RenderWidgetHostImpl::InitForFrame() {
-  DCHECK(process_->IsInitializedAndNotDead());
+  DCHECK(GetProcess()->IsInitializedAndNotDead());
   set_renderer_initialized(true);
 
   // In situations where RenderFrameHostImpl::CreateNewFrame calls this
@@ -696,7 +698,7 @@
   RejectMouseLockOrUnlockIfNecessary(
       blink::mojom::PointerLockResult::kElementDestroyed);
 
-  if (process_->IsInitializedAndNotDead() && !owner_delegate()) {
+  if (GetProcess()->IsInitializedAndNotDead() && !owner_delegate()) {
     // Tell the RendererWidget to close. We only want to do this if the
     // RenderWidget is the root of the renderer object graph, which is for
     // pepper fullscreen and popups.
@@ -725,7 +727,7 @@
 }
 
 bool RenderWidgetHostImpl::Send(IPC::Message* msg) {
-  return process_->Send(msg);
+  return agent_scheduling_group_.Send(msg);
 }
 
 void RenderWidgetHostImpl::SetIsLoading(bool is_loading) {
@@ -756,7 +758,7 @@
   Send(new WidgetMsg_WasHidden(routing_id_));
 
   // Tell the RenderProcessHost we were hidden.
-  process_->UpdateClientPriority(this);
+  GetProcess()->UpdateClientPriority(this);
 
   bool is_visible = false;
   NotificationService::current()->Notify(
@@ -790,7 +792,7 @@
       view_->is_evicted(), std::move(record_tab_switch_time_request)));
   view_->reset_is_evicted();
 
-  process_->UpdateClientPriority(this);
+  GetProcess()->UpdateClientPriority(this);
 
   bool is_visible = true;
   NotificationService::current()->Notify(
@@ -824,7 +826,7 @@
   if (importance_ == importance)
     return;
   importance_ = importance;
-  process_->UpdateClientPriority(this);
+  GetProcess()->UpdateClientPriority(this);
 }
 
 void RenderWidgetHostImpl::AddImeInputEventObserver(
@@ -1088,9 +1090,9 @@
   // is being deleted, or if LocalSurfaceIdAllocation is suppressed, as we are
   // first updating our internal state from a child's request, before
   // subsequently merging ids to send.
-  if (visual_properties_ack_pending_ || !process_->IsInitializedAndNotDead() ||
-      !view_ || !view_->HasSize() || !delegate_ ||
-      surface_id_allocation_suppressed_ ||
+  if (visual_properties_ack_pending_ ||
+      !GetProcess()->IsInitializedAndNotDead() || !view_ || !view_->HasSize() ||
+      !delegate_ || surface_id_allocation_suppressed_ ||
       !view_->CanSynchronizeVisualProperties()) {
     return false;
   }
@@ -1352,8 +1354,8 @@
   DCHECK_GE(mouse_event.GetType(), blink::WebInputEvent::Type::kMouseTypeFirst);
   DCHECK_LE(mouse_event.GetType(), blink::WebInputEvent::Type::kMouseTypeLast);
 
-  for (size_t i = 0; i < mouse_event_callbacks_.size(); ++i) {
-    if (mouse_event_callbacks_[i].Run(mouse_event))
+  for (auto& mouse_event_callback : mouse_event_callbacks_) {
+    if (mouse_event_callback.Run(mouse_event))
       return;
   }
 
@@ -1575,7 +1577,7 @@
   if (IsIgnoringInputEvents())
     return;
 
-  if (!process_->IsInitializedAndNotDead())
+  if (!GetProcess()->IsInitializedAndNotDead())
     return;
 
   // First, let keypress listeners take a shot at handling the event.  If a
@@ -2042,11 +2044,11 @@
   storage::FileSystemContext* file_system_context =
       GetProcess()->GetStoragePartition()->GetFileSystemContext();
   filtered_data.file_system_files.clear();
-  for (size_t i = 0; i < drop_data.file_system_files.size(); ++i) {
+  for (const auto& file_system_file : drop_data.file_system_files) {
     storage::FileSystemURL file_system_url =
-        file_system_context->CrackURL(drop_data.file_system_files[i].url);
+        file_system_context->CrackURL(file_system_file.url);
     if (policy->CanReadFileSystemFile(GetProcess()->GetID(), file_system_url))
-      filtered_data.file_system_files.push_back(drop_data.file_system_files[i]);
+      filtered_data.file_system_files.push_back(file_system_file);
   }
 
   float scale = GetScaleFactorForView(GetView());
@@ -2084,7 +2086,7 @@
   if (!is_hidden_) {
     is_hidden_ = true;
     if (!destroyed_)
-      process_->UpdateClientPriority(this);
+      GetProcess()->UpdateClientPriority(this);
   }
 
   if (view_) {
@@ -2269,11 +2271,11 @@
   }
 
   render_process_blocked_state_changed_subscription_.reset();
-  process_->RemovePriorityClient(this);
-  process_->RemoveObserver(this);
-  process_->RemoveRoute(routing_id_);
+  GetProcess()->RemovePriorityClient(this);
+  GetProcess()->RemoveObserver(this);
+  agent_scheduling_group_.RemoveRoute(routing_id_);
   g_routing_id_widget_map.Get().erase(
-      RenderWidgetHostID(process_->GetID(), routing_id_));
+      RenderWidgetHostID(GetProcess()->GetID(), routing_id_));
 
   // The |delegate_| may have been destroyed (or is in the process of being
   // destroyed) and detached first.
@@ -2812,7 +2814,7 @@
       event.GetType() != WebInputEvent::Type::kTouchCancel)
     return blink::mojom::InputEventResultState::kNoConsumerExists;
 
-  if (!process_->IsInitializedAndNotDead())
+  if (!GetProcess()->IsInitializedAndNotDead())
     return blink::mojom::InputEventResultState::kUnknown;
 
   if (delegate_) {
@@ -3003,7 +3005,7 @@
 }
 
 bool RenderWidgetHostImpl::IsIgnoringInputEvents() const {
-  return process_->IsBlocked() || !delegate_ ||
+  return agent_scheduling_group_.GetProcess()->IsBlocked() || !delegate_ ||
          delegate_->ShouldIgnoreInputEvents();
 }
 

diff --git a/content/browser/renderer_host/render_widget_host_impl.h b/content/browser/renderer_host/render_widget_host_impl.h
index d27e3b98..b2dfde2 100644
--- a/content/browser/renderer_host/render_widget_host_impl.h
+++ b/content/browser/renderer_host/render_widget_host_impl.h

@@ -97,6 +97,7 @@
 }
 
 namespace content {
+class AgentSchedulingGroupHost;
 class BrowserAccessibilityManager;
 class FlingSchedulerBase;
 class InputRouter;
@@ -154,7 +155,7 @@
   // |delegate| goes away.
   RenderWidgetHostImpl(
       RenderWidgetHostDelegate* delegate,
-      RenderProcessHost* process,
+      AgentSchedulingGroupHost& agent_scheduling_host,
       int32_t routing_id,
       bool hidden,
       std::unique_ptr<FrameTokenMessageQueue> frame_token_message_queue);
@@ -1065,7 +1066,7 @@
   bool destroyed_ = false;
 
   // Our delegate, which wants to know mainly about keyboard events.
-  // It will remain non-NULL until DetachDelegate() is called.
+  // It will remain non-null until DetachDelegate() is called.
   RenderWidgetHostDelegate* delegate_;
 
   // The delegate of the owner of this object.
@@ -1073,9 +1074,10 @@
   // with a main frame RenderWidget.
   RenderWidgetHostOwnerDelegate* owner_delegate_ = nullptr;
 
-  // Created during construction and guaranteed never to be NULL, but its
-  // channel may be NULL if the renderer crashed, so one must always check that.
-  RenderProcessHost* const process_;
+  // AgentSchedulingGroupHost to be used for IPC with the corresponding
+  // (renderer-side) AgentSchedulingGroup. Its channel may be nullptr if the
+  // renderer crashed.
+  AgentSchedulingGroupHost& agent_scheduling_group_;
 
   // The ID of the corresponding object in the Renderer Instance.
   const int routing_id_;

diff --git a/content/browser/renderer_host/render_widget_host_input_event_router_unittest.cc b/content/browser/renderer_host/render_widget_host_input_event_router_unittest.cc
index 8a0e883..094d542 100644
--- a/content/browser/renderer_host/render_widget_host_input_event_router_unittest.cc
+++ b/content/browser/renderer_host/render_widget_host_input_event_router_unittest.cc

@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 #include "content/browser/renderer_host/render_widget_host_input_event_router.h"
+#include <memory>
 
 #include "base/run_loop.h"
 #include "base/test/task_environment.h"
@@ -12,6 +13,7 @@
 #include "components/viz/test/host_frame_sink_manager_test_api.h"
 #include "content/browser/compositor/surface_utils.h"
 #include "content/browser/compositor/test/test_image_transport_factory.h"
+#include "content/browser/renderer_host/agent_scheduling_group_host.h"
 #include "content/browser/renderer_host/frame_connector_delegate.h"
 #include "content/browser/renderer_host/frame_token_message_queue.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
@@ -226,8 +228,10 @@
 
     process_host_root_ =
         std::make_unique<MockRenderProcessHost>(browser_context_.get());
+    agent_scheduling_group_host_root_ =
+        std::make_unique<AgentSchedulingGroupHost>(*process_host_root_);
     widget_host_root_ = std::make_unique<RenderWidgetHostImpl>(
-        &delegate_, process_host_root_.get(),
+        &delegate_, *agent_scheduling_group_host_root_,
         process_host_root_->GetNextRoutingID(),
         /*hidden=*/false, std::make_unique<FrameTokenMessageQueue>());
 
@@ -265,6 +269,7 @@
 
   struct ChildViewState {
     std::unique_ptr<MockRenderProcessHost> process_host;
+    std::unique_ptr<AgentSchedulingGroupHost> agent_scheduling_group_host;
     std::unique_ptr<RenderWidgetHostImpl> widget_host;
     std::unique_ptr<TestRenderWidgetHostViewChildFrame> view;
     std::unique_ptr<MockFrameConnectorDelegate> frame_connector;
@@ -275,8 +280,10 @@
 
     child.process_host =
         std::make_unique<MockRenderProcessHost>(browser_context_.get());
+    child.agent_scheduling_group_host =
+        std::make_unique<AgentSchedulingGroupHost>(*child.process_host);
     child.widget_host = std::make_unique<RenderWidgetHostImpl>(
-        &delegate_, child.process_host.get(),
+        &delegate_, *child.agent_scheduling_group_host,
         child.process_host->GetNextRoutingID(),
         /*hidden=*/false, std::make_unique<FrameTokenMessageQueue>());
     child.view = std::make_unique<TestRenderWidgetHostViewChildFrame>(
@@ -324,6 +331,7 @@
   std::unique_ptr<BrowserContext> browser_context_;
 
   std::unique_ptr<MockRenderProcessHost> process_host_root_;
+  std::unique_ptr<AgentSchedulingGroupHost> agent_scheduling_group_host_root_;
   std::unique_ptr<RenderWidgetHostImpl> widget_host_root_;
   std::unique_ptr<MockRootRenderWidgetHostView> view_root_;
   std::unique_ptr<MockInputTargetClient> input_target_client_root_;

diff --git a/content/browser/renderer_host/render_widget_host_unittest.cc b/content/browser/renderer_host/render_widget_host_unittest.cc
index 4b68c1f1a..8cb543a 100644
--- a/content/browser/renderer_host/render_widget_host_unittest.cc
+++ b/content/browser/renderer_host/render_widget_host_unittest.cc

@@ -27,6 +27,7 @@
 #include "components/viz/common/surfaces/parent_local_surface_id_allocator.h"
 #include "components/viz/test/begin_frame_args_test.h"
 #include "content/browser/gpu/compositor_util.h"
+#include "content/browser/renderer_host/agent_scheduling_group_host.h"
 #include "content/browser/renderer_host/display_feature.h"
 #include "content/browser/renderer_host/frame_token_message_queue.h"
 #include "content/browser/renderer_host/input/mock_input_router.h"
@@ -491,12 +492,8 @@
 
 class RenderWidgetHostTest : public testing::Test {
  public:
-  RenderWidgetHostTest()
-      : process_(nullptr),
-        handle_key_press_event_(false),
-        handle_mouse_event_(false),
-        last_simulated_event_time_(ui::EventTimeForNow()) {}
-  ~RenderWidgetHostTest() override {}
+  RenderWidgetHostTest() : last_simulated_event_time_(ui::EventTimeForNow()) {}
+  ~RenderWidgetHostTest() override = default;
 
   bool KeyPressEventCallback(const NativeWebKeyboardEvent& /* event */) {
     return handle_key_press_event_;
@@ -523,9 +520,11 @@
   void SetUp() override {
     base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
     command_line->AppendSwitch(switches::kValidateInputEventStream);
-    browser_context_.reset(new TestBrowserContext());
-    delegate_.reset(new MockRenderWidgetHostDelegate());
+    browser_context_ = std::make_unique<TestBrowserContext>();
+    delegate_ = std::make_unique<MockRenderWidgetHostDelegate>();
     process_ = new RenderWidgetHostProcess(browser_context_.get());
+    agent_scheduling_group_host_ =
+        std::make_unique<AgentSchedulingGroupHost>(*process_);
     sink_ = &process_->sink();
 #if defined(USE_AURA) || defined(OS_MAC)
     ImageTransportFactory::SetFactory(
@@ -539,9 +538,9 @@
     screen_.reset(aura::TestScreen::Create(gfx::Size()));
     display::Screen::SetScreenInstance(screen_.get());
 #endif
-    host_.reset(MockRenderWidgetHost::Create(delegate_.get(), process_,
-                                             process_->GetNextRoutingID(),
-                                             widget_.GetNewRemote()));
+    host_.reset(MockRenderWidgetHost::Create(
+        delegate_.get(), *agent_scheduling_group_host_,
+        process_->GetNextRoutingID(), widget_.GetNewRemote()));
     // Set up the RenderWidgetHost as being for a main frame.
     host_->set_owner_delegate(&mock_owner_delegate_);
     // Act like there is no RenderWidget present in the renderer yet.
@@ -770,14 +769,16 @@
   BrowserTaskEnvironment task_environment_{
       base::test::TaskEnvironment::TimeSource::MOCK_TIME};
   std::unique_ptr<TestBrowserContext> browser_context_;
-  RenderWidgetHostProcess* process_;  // Deleted automatically by the widget.
+  RenderWidgetHostProcess* process_ =
+      nullptr;  // Deleted automatically by the widget.
+  std::unique_ptr<AgentSchedulingGroupHost> agent_scheduling_group_host_;
   std::unique_ptr<MockRenderWidgetHostDelegate> delegate_;
   testing::NiceMock<MockRenderWidgetHostOwnerDelegate> mock_owner_delegate_;
   std::unique_ptr<MockRenderWidgetHost> host_;
   std::unique_ptr<TestView> view_;
   std::unique_ptr<display::Screen> screen_;
-  bool handle_key_press_event_;
-  bool handle_mouse_event_;
+  bool handle_key_press_event_ = false;
+  bool handle_mouse_event_ = false;
   base::TimeTicks last_simulated_event_time_;
   base::TimeDelta simulated_event_time_delta_;
   IPC::TestSink* sink_;

diff --git a/content/browser/renderer_host/render_widget_host_view_android_unittest.cc b/content/browser/renderer_host/render_widget_host_view_android_unittest.cc
index caa3c5c..e352c62 100644
--- a/content/browser/renderer_host/render_widget_host_view_android_unittest.cc
+++ b/content/browser/renderer_host/render_widget_host_view_android_unittest.cc

@@ -9,6 +9,7 @@
 #include "cc/layers/deadline_policy.h"
 #include "cc/layers/layer.h"
 #include "components/viz/common/surfaces/local_surface_id_allocation.h"
+#include "content/browser/renderer_host/agent_scheduling_group_host.h"
 #include "content/browser/renderer_host/mock_render_widget_host.h"
 #include "content/public/test/browser_task_environment.h"
 #include "content/public/test/mock_render_process_host.h"
@@ -47,6 +48,7 @@
  private:
   std::unique_ptr<TestBrowserContext> browser_context_;
   MockRenderProcessHost* process_;  // Deleted automatically by the widget.
+  std::unique_ptr<AgentSchedulingGroupHost> agent_scheduling_group_;
   std::unique_ptr<MockRenderWidgetHostDelegate> delegate_;
   scoped_refptr<cc::Layer> parent_layer_;
   scoped_refptr<cc::Layer> layer_;
@@ -80,8 +82,10 @@
   browser_context_.reset(new TestBrowserContext());
   delegate_.reset(new MockRenderWidgetHostDelegate());
   process_ = new MockRenderProcessHost(browser_context_.get());
-  host_.reset(MockRenderWidgetHost::Create(delegate_.get(), process_,
-                                           process_->GetNextRoutingID()));
+  agent_scheduling_group_ =
+      std::make_unique<AgentSchedulingGroupHost>(*process_);
+  host_.reset(MockRenderWidgetHost::Create(
+      delegate_.get(), *agent_scheduling_group_, process_->GetNextRoutingID()));
   parent_layer_ = cc::Layer::Create();
   parent_view_.SetLayer(parent_layer_);
   layer_ = cc::Layer::Create();
@@ -97,6 +101,7 @@
   render_widget_host_view_android_->Destroy();
   host_.reset();
   delegate_.reset();
+  agent_scheduling_group_ = nullptr;
   process_ = nullptr;
   browser_context_.reset();
 }

diff --git a/content/browser/renderer_host/render_widget_host_view_aura_unittest.cc b/content/browser/renderer_host/render_widget_host_view_aura_unittest.cc
index 2d4c0e4..f793384 100644
--- a/content/browser/renderer_host/render_widget_host_view_aura_unittest.cc
+++ b/content/browser/renderer_host/render_widget_host_view_aura_unittest.cc

@@ -39,6 +39,7 @@
 #include "content/browser/compositor/test/test_image_transport_factory.h"
 #include "content/browser/frame_host/frame_tree.h"
 #include "content/browser/gpu/compositor_util.h"
+#include "content/browser/renderer_host/agent_scheduling_group_host.h"
 #include "content/browser/renderer_host/delegated_frame_host.h"
 #include "content/browser/renderer_host/delegated_frame_host_client_aura.h"
 #include "content/browser/renderer_host/frame_token_message_queue.h"
@@ -390,10 +391,12 @@
     return widget_.ReceivedScreenRects();
   }
 
-  static MockRenderWidgetHostImpl* Create(RenderWidgetHostDelegate* delegate,
-                                          RenderProcessHost* process,
-                                          int32_t routing_id) {
-    return new MockRenderWidgetHostImpl(delegate, process, routing_id);
+  static MockRenderWidgetHostImpl* Create(
+      RenderWidgetHostDelegate* delegate,
+      AgentSchedulingGroupHost& agent_scheduling_group,
+      int32_t routing_id) {
+    return new MockRenderWidgetHostImpl(delegate, agent_scheduling_group,
+                                        routing_id);
   }
   ui::LatencyInfo lastWheelOrTouchEventLatencyInfo;
 
@@ -417,10 +420,10 @@
 
  private:
   MockRenderWidgetHostImpl(RenderWidgetHostDelegate* delegate,
-                           RenderProcessHost* process,
+                           AgentSchedulingGroupHost& agent_scheduling_group,
                            int32_t routing_id)
       : RenderWidgetHostImpl(delegate,
-                             process,
+                             agent_scheduling_group,
                              routing_id,
                              /*hidden=*/false,
                              std::make_unique<FrameTokenMessageQueue>()) {
@@ -504,7 +507,7 @@
     int32_t routing_id = process_host_->GetNextRoutingID();
     delegates_.push_back(base::WrapUnique(new MockRenderWidgetHostDelegate));
     auto* widget_host = MockRenderWidgetHostImpl::Create(
-        delegates_.back().get(), process_host_, routing_id);
+        delegates_.back().get(), *agent_scheduling_group_host_, routing_id);
     delegates_.back()->set_widget_host(widget_host);
     delegates_.back()->set_frame_tree(GetFrameTree());
     widget_host->Init();
@@ -536,6 +539,8 @@
     browser_context_ = std::make_unique<TestBrowserContext>();
     process_host_ = new MockRenderProcessHost(browser_context_.get());
     process_host_->Init();
+    agent_scheduling_group_host_ =
+        std::make_unique<AgentSchedulingGroupHost>(*process_host_);
 
     sink_ = &process_host_->sink();
 
@@ -544,8 +549,8 @@
 
     int32_t routing_id = process_host_->GetNextRoutingID();
     delegates_.push_back(std::make_unique<MockRenderWidgetHostDelegate>());
-    parent_host_ = MockRenderWidgetHostImpl::Create(delegates_.back().get(),
-                                                    process_host_, routing_id);
+    parent_host_ = MockRenderWidgetHostImpl::Create(
+        delegates_.back().get(), *agent_scheduling_group_host_, routing_id);
     delegates_.back()->set_widget_host(parent_host_);
     delegates_.back()->set_frame_tree(GetFrameTree());
     parent_view_ = new RenderWidgetHostViewAura(parent_host_);
@@ -575,8 +580,9 @@
     parent_view_->Destroy();
     delete parent_host_;
 
-    web_contents_.reset();
-    browser_context_.reset();
+    agent_scheduling_group_host_ = nullptr;
+    web_contents_ = nullptr;
+    browser_context_ = nullptr;
     aura_test_helper_->TearDown();
 
     base::RunLoop().RunUntilIdle();
@@ -662,6 +668,7 @@
   std::unique_ptr<WebContents> web_contents_;
   std::vector<std::unique_ptr<MockRenderWidgetHostDelegate>> delegates_;
   MockRenderProcessHost* process_host_;
+  std::unique_ptr<AgentSchedulingGroupHost> agent_scheduling_group_host_;
 
   // Tests should set these to nullptr if they've already triggered their
   // destruction.
@@ -3216,8 +3223,8 @@
   for (size_t i = 0; i < renderer_count; ++i) {
     int32_t routing_id = process_host_->GetNextRoutingID();
     delegates_.push_back(base::WrapUnique(new MockRenderWidgetHostDelegate));
-    hosts[i] = MockRenderWidgetHostImpl::Create(delegates_.back().get(),
-                                                process_host_, routing_id);
+    hosts[i] = MockRenderWidgetHostImpl::Create(
+        delegates_.back().get(), *agent_scheduling_group_host_, routing_id);
     delegates_.back()->set_widget_host(hosts[i]);
     delegates_.back()->set_frame_tree(GetFrameTree());
     hosts[i]->Init();
@@ -3331,8 +3338,8 @@
     int32_t routing_id = process_host_->GetNextRoutingID();
 
     delegates_.push_back(base::WrapUnique(new MockRenderWidgetHostDelegate));
-    hosts[i] = MockRenderWidgetHostImpl::Create(delegates_.back().get(),
-                                                process_host_, routing_id);
+    hosts[i] = MockRenderWidgetHostImpl::Create(
+        delegates_.back().get(), *agent_scheduling_group_host_, routing_id);
     delegates_.back()->set_widget_host(hosts[i]);
     delegates_.back()->set_frame_tree(GetFrameTree());
     hosts[i]->Init();
@@ -5716,27 +5723,34 @@
 // the other two are in distinct processes (this makes a total of 4 RWHVs).
 class InputMethodAuraTestBase : public RenderWidgetHostViewAuraTest {
  public:
-  InputMethodAuraTestBase() {}
-  ~InputMethodAuraTestBase() override {}
+  InputMethodAuraTestBase() = default;
+  ~InputMethodAuraTestBase() override = default;
 
   void SetUp() override {
     RenderWidgetHostViewAuraTest::SetUp();
     InitializeAura();
 
     widget_host_for_first_process_ =
-        CreateRenderWidgetHostForProcess(tab_process());
+        CreateRenderWidgetHostForAgentSchedulingGroup(
+            tab_agent_scheduling_group());
     view_for_first_process_ =
         CreateViewForProcess(widget_host_for_first_process_);
 
     second_process_host_ = CreateNewProcessHost();
+    second_agent_scheduling_group_host_ =
+        std::make_unique<AgentSchedulingGroupHost>(*second_process_host_);
     widget_host_for_second_process_ =
-        CreateRenderWidgetHostForProcess(second_process_host_);
+        CreateRenderWidgetHostForAgentSchedulingGroup(
+            *second_agent_scheduling_group_host_);
     view_for_second_process_ =
         CreateViewForProcess(widget_host_for_second_process_);
 
     third_process_host_ = CreateNewProcessHost();
+    third_agent_scheduling_group_host_ =
+        std::make_unique<AgentSchedulingGroupHost>(*third_process_host_);
     widget_host_for_third_process_ =
-        CreateRenderWidgetHostForProcess(third_process_host_);
+        CreateRenderWidgetHostForAgentSchedulingGroup(
+            *third_agent_scheduling_group_host_);
     view_for_third_process_ =
         CreateViewForProcess(widget_host_for_third_process_);
 
@@ -5780,11 +5794,11 @@
     return process_host;
   }
 
-  MockRenderWidgetHostImpl* CreateRenderWidgetHostForProcess(
-      MockRenderProcessHost* process_host) {
-    return MockRenderWidgetHostImpl::Create(render_widget_host_delegate(),
-                                            process_host,
-                                            process_host->GetNextRoutingID());
+  MockRenderWidgetHostImpl* CreateRenderWidgetHostForAgentSchedulingGroup(
+      AgentSchedulingGroupHost& agent_scheduling_group_host) {
+    return MockRenderWidgetHostImpl::Create(
+        render_widget_host_delegate(), agent_scheduling_group_host,
+        agent_scheduling_group_host.GetProcess()->GetNextRoutingID());
   }
 
   TestRenderWidgetHostView* CreateViewForProcess(
@@ -5803,6 +5817,10 @@
 
   MockRenderProcessHost* tab_process() const { return process_host_; }
 
+  AgentSchedulingGroupHost& tab_agent_scheduling_group() const {
+    return *agent_scheduling_group_host_;
+  }
+
   RenderWidgetHostViewAura* tab_view() const { return view_; }
 
   MockRenderWidgetHostImpl* tab_widget_host() const { return widget_host_; }
@@ -5826,9 +5844,11 @@
   MockRenderWidgetHostImpl* widget_host_for_first_process_;
   TestRenderWidgetHostView* view_for_first_process_;
   MockRenderProcessHost* second_process_host_;
+  std::unique_ptr<AgentSchedulingGroupHost> second_agent_scheduling_group_host_;
   MockRenderWidgetHostImpl* widget_host_for_second_process_;
   TestRenderWidgetHostView* view_for_second_process_;
   MockRenderProcessHost* third_process_host_;
+  std::unique_ptr<AgentSchedulingGroupHost> third_agent_scheduling_group_host_;
   MockRenderWidgetHostImpl* widget_host_for_third_process_;
   TestRenderWidgetHostView* view_for_third_process_;
 

diff --git a/content/browser/renderer_host/render_widget_host_view_child_frame_unittest.cc b/content/browser/renderer_host/render_widget_host_view_child_frame_unittest.cc
index b861375..b4e84fdf 100644
--- a/content/browser/renderer_host/render_widget_host_view_child_frame_unittest.cc
+++ b/content/browser/renderer_host/render_widget_host_view_child_frame_unittest.cc

@@ -21,6 +21,7 @@
 #include "components/viz/test/fake_external_begin_frame_source.h"
 #include "content/browser/compositor/test/test_image_transport_factory.h"
 #include "content/browser/gpu/compositor_util.h"
+#include "content/browser/renderer_host/agent_scheduling_group_host.h"
 #include "content/browser/renderer_host/frame_connector_delegate.h"
 #include "content/browser/renderer_host/frame_token_message_queue.h"
 #include "content/browser/renderer_host/render_widget_host_delegate.h"
@@ -115,14 +116,15 @@
         std::make_unique<TestImageTransportFactory>());
 #endif
 
-    MockRenderProcessHost* process_host =
-        new MockRenderProcessHost(browser_context_.get());
+    auto* process_host = new MockRenderProcessHost(browser_context_.get());
 
+    agent_scheduling_group_host_ =
+        std::make_unique<AgentSchedulingGroupHost>(*process_host);
     int32_t routing_id = process_host->GetNextRoutingID();
     sink_ = &process_host->sink();
 
     widget_host_ = new RenderWidgetHostImpl(
-        &delegate_, process_host, routing_id,
+        &delegate_, *agent_scheduling_group_host_, routing_id,
         /*hidden=*/false, std::make_unique<FrameTokenMessageQueue>());
 
     mojo::AssociatedRemote<blink::mojom::WidgetHost> blink_widget_host;
@@ -157,6 +159,7 @@
     if (view_)
       view_->Destroy();
     delete widget_host_;
+    agent_scheduling_group_host_ = nullptr;
     delete test_frame_connector_;
 
     browser_context_.reset();
@@ -181,6 +184,7 @@
   BrowserTaskEnvironment task_environment_;
 
   std::unique_ptr<BrowserContext> browser_context_;
+  std::unique_ptr<AgentSchedulingGroupHost> agent_scheduling_group_host_;
   IPC::TestSink* sink_ = nullptr;
   MockRenderWidgetHostDelegate delegate_;
   MockWidget widget_;

diff --git a/content/browser/renderer_host/render_widget_host_view_mac_editcommand_helper_unittest.mm b/content/browser/renderer_host/render_widget_host_view_mac_editcommand_helper_unittest.mm
index 3ed2a550..006c0f6 100644
--- a/content/browser/renderer_host/render_widget_host_view_mac_editcommand_helper_unittest.mm
+++ b/content/browser/renderer_host/render_widget_host_view_mac_editcommand_helper_unittest.mm

@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 #import "content/browser/renderer_host/render_widget_host_view_mac_editcommand_helper.h"
+#include "content/browser/renderer_host/agent_scheduling_group_host.h"
 
 #import <Cocoa/Cocoa.h>
 #include <stddef.h>
@@ -13,6 +14,7 @@
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/browser/compositor/test/test_image_transport_factory.h"
 #include "content/browser/gpu/compositor_util.h"
+#include "content/browser/renderer_host/agent_scheduling_group_host.h"
 #include "content/browser/renderer_host/frame_token_message_queue.h"
 #include "content/browser/renderer_host/render_widget_host_delegate.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
@@ -138,7 +140,8 @@
   MockRenderProcessHostFactory process_host_factory;
   RenderProcessHost* process_host =
       process_host_factory.CreateRenderProcessHost(&browser_context, nullptr);
-
+  auto agent_scheduling_group_host =
+      std::make_unique<AgentSchedulingGroupHost>(*process_host);
   // Populates |g_supported_scale_factors|.
   std::vector<ui::ScaleFactor> supported_factors;
   supported_factors.push_back(ui::SCALE_FACTOR_100P);
@@ -147,7 +150,7 @@
   @autoreleasepool {
     int32_t routing_id = process_host->GetNextRoutingID();
     RenderWidgetHostImpl* render_widget = new RenderWidgetHostImpl(
-        &delegate, process_host, routing_id,
+        &delegate, *agent_scheduling_group_host, routing_id,
         /*hidden=*/false, std::make_unique<FrameTokenMessageQueue>());
 
     ui::WindowResizeHelperMac::Get()->Init(base::ThreadTaskRunnerHandle::Get());

diff --git a/content/browser/renderer_host/render_widget_host_view_mac_unittest.mm b/content/browser/renderer_host/render_widget_host_view_mac_unittest.mm
index b6f3c58..1af999b 100644
--- a/content/browser/renderer_host/render_widget_host_view_mac_unittest.mm
+++ b/content/browser/renderer_host/render_widget_host_view_mac_unittest.mm

@@ -27,6 +27,7 @@
 #import "content/app_shim_remote_cocoa/render_widget_host_view_cocoa.h"
 #include "content/browser/compositor/image_transport_factory.h"
 #include "content/browser/gpu/compositor_util.h"
+#include "content/browser/renderer_host/agent_scheduling_group_host.h"
 #include "content/browser/renderer_host/frame_token_message_queue.h"
 #include "content/browser/renderer_host/render_widget_host_delegate.h"
 #include "content/browser/renderer_host/text_input_manager.h"
@@ -336,10 +337,12 @@
   MOCK_METHOD0(Blur, void());
 
   ui::LatencyInfo lastWheelEventLatencyInfo;
-  static MockRenderWidgetHostImpl* Create(RenderWidgetHostDelegate* delegate,
-                                          RenderProcessHost* process,
-                                          int32_t routing_id) {
-    return new MockRenderWidgetHostImpl(delegate, process, routing_id);
+  static MockRenderWidgetHostImpl* Create(
+      RenderWidgetHostDelegate* delegate,
+      AgentSchedulingGroupHost& agent_scheduling_group_host,
+      int32_t routing_id) {
+    return new MockRenderWidgetHostImpl(delegate, agent_scheduling_group_host,
+                                        routing_id);
   }
 
   MockWidgetInputHandler* input_handler() { return &input_handler_; }
@@ -352,11 +355,12 @@
   }
 
  private:
-  MockRenderWidgetHostImpl(RenderWidgetHostDelegate* delegate,
-                           RenderProcessHost* process,
-                           int32_t routing_id)
+  MockRenderWidgetHostImpl(
+      RenderWidgetHostDelegate* delegate,
+      AgentSchedulingGroupHost& agent_scheduling_group_host,
+      int32_t routing_id)
       : RenderWidgetHostImpl(delegate,
-                             process,
+                             agent_scheduling_group_host,
                              routing_id,
                              /*hidden=*/false,
                              std::make_unique<FrameTokenMessageQueue>()) {
@@ -480,8 +484,11 @@
     process_host_ =
         std::make_unique<MockRenderProcessHost>(browser_context_.get());
     process_host_->Init();
+    agent_scheduling_group_host_ =
+        std::make_unique<AgentSchedulingGroupHost>(*process_host_);
     host_ = base::WrapUnique(MockRenderWidgetHostImpl::Create(
-        &delegate_, process_host_.get(), process_host_->GetNextRoutingID()));
+        &delegate_, *agent_scheduling_group_host_,
+        process_host_->GetNextRoutingID()));
     host_->set_owner_delegate(&mock_owner_delegate_);
     rwhv_mac_ = new RenderWidgetHostViewMac(host_.get());
     rwhv_cocoa_.reset([rwhv_mac_->GetInProcessNSView() retain]);
@@ -535,6 +542,7 @@
 
   std::unique_ptr<TestBrowserContext> browser_context_;
   std::unique_ptr<MockRenderProcessHost> process_host_;
+  std::unique_ptr<AgentSchedulingGroupHost> agent_scheduling_group_host_;
   testing::NiceMock<MockRenderWidgetHostOwnerDelegate> mock_owner_delegate_;
   std::unique_ptr<MockRenderWidgetHostImpl> host_;
   RenderWidgetHostViewMac* rwhv_mac_ = nullptr;
@@ -1300,10 +1308,11 @@
   MockRenderProcessHost* process_host =
       new MockRenderProcessHost(&browser_context);
   process_host->Init();
+  AgentSchedulingGroupHost agent_scheduling_group_host(*process_host);
   MockRenderWidgetHostDelegate delegate;
   int32_t routing_id = process_host->GetNextRoutingID();
-  MockRenderWidgetHostImpl* host =
-      MockRenderWidgetHostImpl::Create(&delegate, process_host, routing_id);
+  MockRenderWidgetHostImpl* host = MockRenderWidgetHostImpl::Create(
+      &delegate, agent_scheduling_group_host, routing_id);
   RenderWidgetHostViewMac* view = new RenderWidgetHostViewMac(host);
   base::RunLoop().RunUntilIdle();
 
@@ -1360,10 +1369,11 @@
   MockRenderProcessHost* process_host =
       new MockRenderProcessHost(&browser_context);
   process_host->Init();
+  AgentSchedulingGroupHost agent_scheduling_group_host(*process_host);
   MockRenderWidgetHostDelegate delegate;
   int32_t routing_id = process_host->GetNextRoutingID();
-  MockRenderWidgetHostImpl* host =
-      MockRenderWidgetHostImpl::Create(&delegate, process_host, routing_id);
+  MockRenderWidgetHostImpl* host = MockRenderWidgetHostImpl::Create(
+      &delegate, agent_scheduling_group_host, routing_id);
   RenderWidgetHostViewMac* view = new RenderWidgetHostViewMac(host);
   base::RunLoop().RunUntilIdle();
 
@@ -1417,9 +1427,10 @@
       new MockRenderProcessHost(&browser_context);
   process_host->Init();
   MockRenderWidgetHostDelegate delegate;
+  AgentSchedulingGroupHost agent_scheduling_group_host(*process_host);
   int32_t routing_id = process_host->GetNextRoutingID();
-  MockRenderWidgetHostImpl* host =
-      MockRenderWidgetHostImpl::Create(&delegate, process_host, routing_id);
+  MockRenderWidgetHostImpl* host = MockRenderWidgetHostImpl::Create(
+      &delegate, agent_scheduling_group_host, routing_id);
   RenderWidgetHostViewMac* view = new RenderWidgetHostViewMac(host);
   base::RunLoop().RunUntilIdle();
 
@@ -1734,8 +1745,10 @@
     child_process_host_ =
         new MockRenderProcessHost(child_browser_context_.get());
     child_process_host_->Init();
+    child_agent_scheduling_group_host_ =
+        std::make_unique<AgentSchedulingGroupHost>(*child_process_host_);
     child_widget_ = MockRenderWidgetHostImpl::Create(
-        &delegate_, child_process_host_,
+        &delegate_, *child_agent_scheduling_group_host_,
         child_process_host_->GetNextRoutingID());
     child_view_ = new TestRenderWidgetHostView(child_widget_);
     base::RunLoop().RunUntilIdle();
@@ -1773,6 +1786,7 @@
 
  protected:
   MockRenderProcessHost* child_process_host_;
+  std::unique_ptr<AgentSchedulingGroupHost> child_agent_scheduling_group_host_;
   MockRenderWidgetHostImpl* child_widget_;
   TestRenderWidgetHostView* child_view_;
 

diff --git a/content/browser/site_per_process_browsertest.cc b/content/browser/site_per_process_browsertest.cc
index 8ea082f..d5610285 100644
--- a/content/browser/site_per_process_browsertest.cc
+++ b/content/browser/site_per_process_browsertest.cc

@@ -13730,9 +13730,9 @@
 // reload. This avoids showing crashed subframes if a hidden tab is eventually
 // shown. See https://crbug.com/841572.
 // crbug.com/1010119, fails on Win. crbug.com/1015971, fails on Linux.
-// crbug.com/1049885, fails on Android.
+// crbug.com/1049885, fails on Android and Mac.
 #if defined(OS_WIN) || defined(OS_LINUX) || defined(OS_CHROMEOS) || \
-    defined(OS_ANDROID)
+    defined(OS_ANDROID) || defined(OS_MACOSX)
 #define MAYBE_ReloadHiddenTabWithCrashedSubframe \
   DISABLED_ReloadHiddenTabWithCrashedSubframe
 #else

diff --git a/content/browser/tracing/background_tracing_rule.cc b/content/browser/tracing/background_tracing_rule.cc
index 45319ec..8647c03b 100644
--- a/content/browser/tracing/background_tracing_rule.cc
+++ b/content/browser/tracing/background_tracing_rule.cc

@@ -250,9 +250,8 @@
     base::StatisticsRecorder::SetCallback(
         histogram_name_,
         base::BindRepeating(&HistogramRule::OnHistogramChangedCallback,
-                            base::Unretained(this), histogram_name_,
-                            histogram_lower_value_, histogram_upper_value_,
-                            repeat_));
+                            base::Unretained(this), histogram_lower_value_,
+                            histogram_upper_value_, repeat_));
 
     BackgroundTracingManagerImpl::GetInstance()->AddAgentObserver(this);
     installed_ = true;
@@ -310,10 +309,11 @@
     agent->ClearUMACallback(histogram_name_);
   }
 
-  void OnHistogramChangedCallback(const std::string& histogram_name,
-                                  base::Histogram::Sample reference_lower_value,
+  void OnHistogramChangedCallback(base::Histogram::Sample reference_lower_value,
                                   base::Histogram::Sample reference_upper_value,
                                   bool repeat,
+                                  const char* histogram_name,
+                                  uint64_t name_hash,
                                   base::Histogram::Sample actual_value) {
     if (reference_lower_value > actual_value ||
         reference_upper_value < actual_value) {

diff --git a/content/browser/web_contents/web_contents_impl.cc b/content/browser/web_contents/web_contents_impl.cc
index 802b728..877a597 100644
--- a/content/browser/web_contents/web_contents_impl.cc
+++ b/content/browser/web_contents/web_contents_impl.cc

@@ -78,6 +78,7 @@
 #include "content/browser/permissions/permission_controller_impl.h"
 #include "content/browser/plugin_content_origin_allowlist.h"
 #include "content/browser/portal/portal.h"
+#include "content/browser/renderer_host/agent_scheduling_group_host.h"
 #include "content/browser/renderer_host/frame_token_message_queue.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/renderer_host/render_view_host_delegate_view.h"
@@ -468,27 +469,28 @@
                            blink::mojom::PermissionStatus::GRANTED;
 }
 
-// Adjust the requested |bounds| for opening or placing a window. The bounds
-// may not extend outside a single screen's work area, and the |host| requires
-// permission to specify bounds on a screen other than its current screen.
+// Adjust the requested |bounds| for opening or placing a window and return the
+// id of the display where the window will be placed. The bounds may not extend
+// outside a single screen's work area, and the |host| requires permission to
+// specify bounds on a screen other than its current screen.
 // TODO(crbug.com/897300): These adjustments are inaccurate for window.open(),
 // which specifies the inner content size, and for window.moveTo, resizeTo, etc.
 // calls on newly created windows, which may pass empty sizes or positions to
 // indicate uninitialized placement information in the renderer. Constraints
 // enforced later should resolve most inaccuracies, but this early enforcement
 // is needed to ensure bounds indicate the appropriate display.
-gfx::Rect AdjustRequestedWindowBounds(gfx::Rect bounds, RenderFrameHost* host) {
+int64_t AdjustRequestedWindowBounds(gfx::Rect* bounds, RenderFrameHost* host) {
   auto* screen = display::Screen::GetScreen();
-  auto display = screen->GetDisplayMatching(bounds);
+  auto display = screen->GetDisplayMatching(*bounds);
 
   // Check, but do not prompt, for permission to place windows on other screens.
   // Sites generally need permission to get such bounds in the first place.
   // Also clamp offscreen bounds to the window's current screen.
-  if (!bounds.Intersects(display.bounds()) || !WindowPlacementGranted(host))
+  if (!bounds->Intersects(display.bounds()) || !WindowPlacementGranted(host))
     display = screen->GetDisplayNearestView(host->GetNativeView());
 
-  bounds.AdjustToFit(display.work_area());
-  return bounds;
+  bounds->AdjustToFit(display.work_area());
+  return display.id();
 }
 
 }  // namespace
@@ -3444,17 +3446,6 @@
                                   true);  // renderer_initiated
   });
 
-  // Any new WebContents opened while this WebContents is in fullscreen can be
-  // used to confuse the user, so drop fullscreen. Sites with Window Placement
-  // permission granted are excepted to support multi-screen window management.
-  // TODO(crbug.com/1120746): Prevent interference with fullscreen security UI.
-  if (!WindowPlacementGranted(opener)) {
-    base::ScopedClosureRunner fullscreen_block = ForSecurityDropFullscreen();
-    // The new contents will be independent of this contents, so release the
-    // fullscreen block.
-    fullscreen_block.RunAndReset();
-  }
-
   if (params.opener_suppressed) {
     // When the opener is suppressed, the original renderer cannot access the
     // new window.  As a result, we need to show and navigate the window here.
@@ -3503,41 +3494,43 @@
 }
 
 void WebContentsImpl::CreateNewWidget(
-    int32_t render_process_id,
-    int32_t widget_route_id,
+    AgentSchedulingGroupHost& agent_scheduling_group,
+    int32_t route_id,
     mojo::PendingAssociatedReceiver<blink::mojom::WidgetHost> blink_widget_host,
     mojo::PendingAssociatedRemote<blink::mojom::Widget> blink_widget) {
-  CreateNewWidget(render_process_id, widget_route_id, /*is_fullscreen=*/false,
-                  std::move(blink_widget_host), std::move(blink_widget));
+  CreateNewWidget(agent_scheduling_group, route_id,
+                  /*is_fullscreen=*/false, std::move(blink_widget_host),
+                  std::move(blink_widget));
 }
 
 void WebContentsImpl::CreateNewFullscreenWidget(
-    int32_t render_process_id,
-    int32_t widget_route_id,
+    AgentSchedulingGroupHost& agent_scheduling_group,
+    int32_t route_id,
     mojo::PendingAssociatedReceiver<blink::mojom::WidgetHost> blink_widget_host,
     mojo::PendingAssociatedRemote<blink::mojom::Widget> blink_widget) {
-  CreateNewWidget(render_process_id, widget_route_id, /*is_fullscreen=*/true,
-                  std::move(blink_widget_host), std::move(blink_widget));
+  CreateNewWidget(agent_scheduling_group, route_id,
+                  /*is_fullscreen=*/true, std::move(blink_widget_host),
+                  std::move(blink_widget));
 }
 
 void WebContentsImpl::CreateNewWidget(
-    int32_t render_process_id,
+    AgentSchedulingGroupHost& agent_scheduling_group,
     int32_t route_id,
     bool is_fullscreen,
     mojo::PendingAssociatedReceiver<blink::mojom::WidgetHost> blink_widget_host,
     mojo::PendingAssociatedRemote<blink::mojom::Widget> blink_widget) {
-  RenderProcessHost* process = RenderProcessHost::FromID(render_process_id);
+  RenderProcessHost* process = agent_scheduling_group.GetProcess();
   // A message to create a new widget can only come from an active process for
   // this WebContentsImpl instance. If any other process sends the request,
   // it is invalid and the process must be terminated.
-  if (!HasMatchingProcess(&frame_tree_, render_process_id)) {
+  if (!HasMatchingProcess(&frame_tree_, process->GetID())) {
     ReceivedBadMessage(process, bad_message::WCI_NEW_WIDGET_PROCESS_MISMATCH);
     return;
   }
 
-  RenderWidgetHostImpl* widget_host =
-      new RenderWidgetHostImpl(this, process, route_id, IsHidden(),
-                               std::make_unique<FrameTokenMessageQueue>());
+  RenderWidgetHostImpl* widget_host = new RenderWidgetHostImpl(
+      this, agent_scheduling_group, route_id, IsHidden(),
+      std::make_unique<FrameTokenMessageQueue>());
 
   widget_host->BindWidgetInterfaces(std::move(blink_widget_host),
                                     std::move(blink_widget));
@@ -3551,7 +3544,7 @@
   if (!is_fullscreen)
     widget_view->SetWidgetType(WidgetType::kPopup);
   // Save the created widget associated with the route so we can show it later.
-  pending_widget_views_[GlobalRoutingID(render_process_id, route_id)] =
+  pending_widget_views_[GlobalRoutingID(process->GetID(), route_id)] =
       widget_view;
 }
 
@@ -3582,6 +3575,22 @@
   // from, to control how to show the newly created window.
   WebContentsDelegate* delegate = GetDelegate();
 
+  // Individual members of |initial_rect| may be 0 to indicate that the
+  // window.open() feature string did not specify a value. This code does not
+  // have the ability to distinguish between an unspecified value and 0.
+  // Assume that if any single value is non-zero, all values should be used.
+  // TODO(crbug.com/897300): Plumb values as specified; set defaults here?
+  gfx::Rect adjusted_rect = initial_rect;
+  int64_t display_id = display::kInvalidDisplayId;
+  if (adjusted_rect != gfx::Rect())
+    display_id = AdjustRequestedWindowBounds(&adjusted_rect, opener);
+
+  // Drop fullscreen when opening a WebContents to prohibit deceptive behavior.
+  // Only drop fullscreen on the specific destination display, if it is known.
+  // This supports sites using cross-screen window placement capabilities to
+  // retain fullscreen and open a window on another screen.
+  ForSecurityDropFullscreen(display_id).RunAndReset();
+
   // The delegate can be null in tests, so we must check for it :(.
   if (delegate) {
     // Mark the web contents as pending resume, then immediately do
@@ -3590,15 +3599,6 @@
     if (delegate->ShouldResumeRequestsForCreatedWindow())
       created->ResumeLoadingCreatedWebContents();
 
-    // Individual members of |initial_rect| may be 0 to indicate that the
-    // window.open() feature string did not specify a value. This code does not
-    // have the ability to distinguish between an unspecified value and 0.
-    // Assume that if any single value is non-zero, all values should be used.
-    // TODO(crbug.com/897300): Plumb values as specified; set defaults here?
-    gfx::Rect adjusted_rect = initial_rect;
-    if (adjusted_rect != gfx::Rect())
-      adjusted_rect = AdjustRequestedWindowBounds(adjusted_rect, opener);
-
     base::WeakPtr<WebContentsImpl> weak_created =
         created->weak_factory_.GetWeakPtr();
     delegate->AddNewContents(this, std::move(owned_created->contents),
@@ -4703,7 +4703,8 @@
   ExitFullscreenMode(will_cause_resize);
 }
 
-base::ScopedClosureRunner WebContentsImpl::ForSecurityDropFullscreen() {
+base::ScopedClosureRunner WebContentsImpl::ForSecurityDropFullscreen(
+    int64_t display_id) {
   // Kick WebContentses that are "related" to this WebContents out of
   // fullscreen. This needs to be done with two passes, because it is simple to
   // walk _up_ the chain of openers and outer contents, but it not simple to
@@ -4715,13 +4716,19 @@
   // contentses x each one's opener length) but neither of those is expected to
   // ever be a large number.
 
+  auto* screen = display::Screen::GetScreen();
+
   auto fullscreen_set_copy = *FullscreenContentsSet(GetBrowserContext());
   for (auto* fullscreen_contents : fullscreen_set_copy) {
     // Checking IsFullscreen() for tabs in the fullscreen set may seem
     // redundant, but teeeeechnically fullscreen is run by the delegate, and
     // it's possible that the delegate's notion of fullscreen may have changed
     // outside of WebContents's notice.
-    if (fullscreen_contents->IsFullscreen()) {
+    if (fullscreen_contents->IsFullscreen() &&
+        (display_id == display::kInvalidDisplayId || !screen ||
+         display_id ==
+             screen->GetDisplayNearestView(fullscreen_contents->GetNativeView())
+                 .id())) {
       auto opener_contentses = GetAllOpeningWebContents(fullscreen_contents);
       if (opener_contentses.count(this))
         fullscreen_contents->ExitFullscreen(true);
@@ -4739,7 +4746,10 @@
 
   for (auto* opener : GetAllOpeningWebContents(this)) {
     // Drop fullscreen if the WebContents is in it, and...
-    if (opener->IsFullscreen())
+    if (opener->IsFullscreen() &&
+        (display_id == display::kInvalidDisplayId || !screen ||
+         display_id ==
+             screen->GetDisplayNearestView(opener->GetNativeView()).id()))
       opener->ExitFullscreen(true);
 
     // ...block the WebContents from entering fullscreen until further notice.
@@ -6538,7 +6548,14 @@
     bounds.set_size(GetContainerBounds().size());
 
   // Only requests from the main frame, not subframes, should reach this code.
-  bounds = AdjustRequestedWindowBounds(bounds, GetMainFrame());
+  int64_t display_id = AdjustRequestedWindowBounds(&bounds, GetMainFrame());
+
+  // Drop fullscreen when placing a WebContents to prohibit deceptive behavior.
+  // Only drop fullscreen on the specific destination display, which is known.
+  // This supports sites using cross-screen window placement capabilities to
+  // retain fullscreen and place a window on another screen.
+  ForSecurityDropFullscreen(display_id).RunAndReset();
+
   delegate_->SetContentsBounds(this, bounds);
 }
 

diff --git a/content/browser/web_contents/web_contents_impl.h b/content/browser/web_contents/web_contents_impl.h
index c6e5a85f..868f1d13 100644
--- a/content/browser/web_contents/web_contents_impl.h
+++ b/content/browser/web_contents/web_contents_impl.h

@@ -96,6 +96,7 @@
 
 namespace content {
 enum class PictureInPictureResult;
+class AgentSchedulingGroupHost;
 class BrowserPluginEmbedder;
 class BrowserPluginGuest;
 class ConversionHost;
@@ -506,7 +507,8 @@
   bool IsFullscreen() override;
   bool ShouldShowStaleContentOnEviction() override;
   void ExitFullscreen(bool will_cause_resize) override;
-  base::ScopedClosureRunner ForSecurityDropFullscreen() override
+  base::ScopedClosureRunner ForSecurityDropFullscreen(
+      int64_t display_id = display::kInvalidDisplayId) override
       WARN_UNUSED_RESULT;
   void ResumeLoadingCreatedWebContents() override;
   void SetIsOverlayContent(bool is_overlay_content) override;
@@ -721,15 +723,15 @@
       RenderFrameHostImpl* source,
       blink::mojom::TextAutosizerPageInfoPtr page_info) override;
   bool HasSeenRecentScreenOrientationChange() override;
-  void CreateNewWidget(int32_t render_process_id,
+  void CreateNewWidget(AgentSchedulingGroupHost& agent_scheduling_group,
                        int32_t route_id,
                        mojo::PendingAssociatedReceiver<blink::mojom::WidgetHost>
                            blink_widget_host,
                        mojo::PendingAssociatedRemote<blink::mojom::Widget>
                            blink_widget) override;
   void CreateNewFullscreenWidget(
-      int32_t render_process_id,
-      int32_t widget_route_id,
+      AgentSchedulingGroupHost& agent_scheduling_group,
+      int32_t route_id,
       mojo::PendingAssociatedReceiver<blink::mojom::WidgetHost>
           blink_widget_host,
       mojo::PendingAssociatedRemote<blink::mojom::Widget> blink_widget)
@@ -1578,7 +1580,7 @@
 
   // Helper for CreateNewWidget/CreateNewFullscreenWidget.
   void CreateNewWidget(
-      int32_t render_process_id,
+      AgentSchedulingGroupHost& agent_scheduling_group,
       int32_t route_id,
       bool is_fullscreen,
       mojo::PendingAssociatedReceiver<blink::mojom::WidgetHost>

diff --git a/content/child/runtime_features.cc b/content/child/runtime_features.cc
index be1e157..a635276 100644
--- a/content/child/runtime_features.cc
+++ b/content/child/runtime_features.cc

@@ -341,7 +341,6 @@
     {wf::EnableMediaFeeds, media::kMediaFeeds, kUseFeatureState},
     {wf::EnableRestrictGamepadAccess, features::kRestrictGamepadAccess,
      kEnableOnly},
-    {wf::EnableCompositeSVG, blink::features::kCompositeSVG, kUseFeatureState},
     {wf::EnableCompositingOptimizations,
      blink::features::kCompositingOptimizations, kUseFeatureState},
     {wf::EnableConversionMeasurementInfraSupport,

diff --git a/content/common/renderer.mojom b/content/common/renderer.mojom
index 727a069..196c8e9 100644
--- a/content/common/renderer.mojom
+++ b/content/common/renderer.mojom

@@ -257,6 +257,9 @@
   // Tells the renderer to create a new RenderFrame.
   CreateFrame(CreateFrameParams params);
 
+  // Tells the renderer to create a new AgentSchedulingGroup.
+  CreateAgentSchedulingGroup();
+
   // Tells the renderer to create a new RenderFrameProxy object with
   // |routing_id|.  |render_view_routing_id| identifies the
   // RenderView to be associated with this proxy. The new proxy's opener should

diff --git a/content/public/android/java/src/org/chromium/content/browser/JavascriptInjectorImpl.java b/content/public/android/java/src/org/chromium/content/browser/JavascriptInjectorImpl.java
index e09218b..efe64749 100644
--- a/content/public/android/java/src/org/chromium/content/browser/JavascriptInjectorImpl.java
+++ b/content/public/android/java/src/org/chromium/content/browser/JavascriptInjectorImpl.java

@@ -80,7 +80,10 @@
 
     @Override
     public void setAllowInspection(boolean allow) {
-        if (mNativePtr != 0) {
+        assert mUseMojo != null;
+        if (mUseMojo) {
+            mInjector.setAllowInspection(allow);
+        } else if (mNativePtr != 0) {
             JavascriptInjectorImplJni.get().setAllowInspection(
                     mNativePtr, JavascriptInjectorImpl.this, allow);
         }

diff --git a/content/public/android/java/src/org/chromium/content/browser/remoteobjects/RemoteObjectHostImpl.java b/content/public/android/java/src/org/chromium/content/browser/remoteobjects/RemoteObjectHostImpl.java
index 2ca07b33..c3309f1f 100644
--- a/content/public/android/java/src/org/chromium/content/browser/remoteobjects/RemoteObjectHostImpl.java
+++ b/content/public/android/java/src/org/chromium/content/browser/remoteobjects/RemoteObjectHostImpl.java

@@ -47,11 +47,15 @@
      */
     private final WeakReference<RemoteObjectRegistry> mRegistry;
 
+    private final boolean mAllowInspection;
+
     RemoteObjectHostImpl(Class<? extends Annotation> safeAnnotationClass,
-            RemoteObjectImpl.Auditor auditor, RemoteObjectRegistry registry) {
+            RemoteObjectImpl.Auditor auditor, RemoteObjectRegistry registry,
+            boolean allowInspection) {
         mSafeAnnotationClass = safeAnnotationClass;
         mAuditor = auditor;
         mRegistry = new WeakReference<>(registry);
+        mAllowInspection = allowInspection;
     }
 
     public RemoteObjectRegistry getRegistry() {
@@ -69,8 +73,8 @@
             if (target == null) {
                 return;
             }
-            RemoteObjectImpl impl =
-                    new RemoteObjectImpl(target, mSafeAnnotationClass, mAuditor, registry);
+            RemoteObjectImpl impl = new RemoteObjectImpl(
+                    target, mSafeAnnotationClass, mAuditor, registry, mAllowInspection);
             RemoteObject.MANAGER.bind(impl, request);
         }
     }

diff --git a/content/public/android/java/src/org/chromium/content/browser/remoteobjects/RemoteObjectImpl.java b/content/public/android/java/src/org/chromium/content/browser/remoteobjects/RemoteObjectImpl.java
index 2b0e33c3..60d65af 100644
--- a/content/public/android/java/src/org/chromium/content/browser/remoteobjects/RemoteObjectImpl.java
+++ b/content/public/android/java/src/org/chromium/content/browser/remoteobjects/RemoteObjectImpl.java

@@ -97,11 +97,17 @@
      */
     private final SortedMap<String, List<Method>> mMethods = new TreeMap<>();
 
+    /**
+     * If true, allows an object context's inspection when {@link #getMethods} is called.
+     */
+    private final boolean mAllowInspection;
+
     public RemoteObjectImpl(Object target, Class<? extends Annotation> safeAnnotationClass,
-            Auditor auditor, ObjectIdAllocator objectIdAllocator) {
+            Auditor auditor, ObjectIdAllocator objectIdAllocator, boolean allowInspection) {
         mTarget = new WeakReference<>(target);
         mAuditor = auditor;
         mObjectIdAllocator = new WeakReference<>(objectIdAllocator);
+        mAllowInspection = allowInspection;
 
         for (Method method : target.getClass().getMethods()) {
             if (safeAnnotationClass != null && !method.isAnnotationPresent(safeAnnotationClass)) {
@@ -125,6 +131,10 @@
 
     @Override
     public void getMethods(GetMethodsResponse callback) {
+        if (!mAllowInspection) {
+            callback.call(new String[0]);
+            return;
+        }
         Set<String> methodNames = mMethods.keySet();
         callback.call(methodNames.toArray(new String[methodNames.size()]));
     }

diff --git a/content/public/android/java/src/org/chromium/content/browser/remoteobjects/RemoteObjectInjector.java b/content/public/android/java/src/org/chromium/content/browser/remoteobjects/RemoteObjectInjector.java
index db3188d..3641a64 100644
--- a/content/public/android/java/src/org/chromium/content/browser/remoteobjects/RemoteObjectInjector.java
+++ b/content/public/android/java/src/org/chromium/content/browser/remoteobjects/RemoteObjectInjector.java

@@ -44,6 +44,7 @@
             new HashMap<>();
     private final Map<RenderFrameHost, RemoteObjectGatewayHelper> mRemoteObjectGatewayHelpers =
             new HashMap<>();
+    private boolean mAllowInspection = true;
 
     public RemoteObjectInjector(WebContents webContents) {
         super(webContents);
@@ -81,6 +82,10 @@
         addInterfaceForFrame(webContents.getMainFrame(), name, object, requiredAnnotation);
     }
 
+    public void setAllowInspection(boolean allow) {
+        mAllowInspection = allow;
+    }
+
     private void addInterfaceForFrame(RenderFrameHost frameHost, String name, Object object,
             Class<? extends Annotation> requiredAnnotation) {
         RemoteObjectGatewayHelper helper =
@@ -97,7 +102,7 @@
 
             // Construct a RemoteObjectHost implementation.
             RemoteObjectHostImpl host = new RemoteObjectHostImpl(
-                    requiredAnnotation, new RemoteObjectAuditorImpl(), registry);
+                    requiredAnnotation, new RemoteObjectAuditorImpl(), registry, mAllowInspection);
 
             RemoteObjectGatewayFactory factory = frameHost.getRemoteInterfaces().getInterface(
                     RemoteObjectGatewayFactory.MANAGER);

diff --git a/content/public/android/javatests/src/org/chromium/content/browser/remoteobjects/RemoteObjectHostImplTest.java b/content/public/android/javatests/src/org/chromium/content/browser/remoteobjects/RemoteObjectHostImplTest.java
index 5563a01..9515f24 100644
--- a/content/public/android/javatests/src/org/chromium/content/browser/remoteobjects/RemoteObjectHostImplTest.java
+++ b/content/public/android/javatests/src/org/chromium/content/browser/remoteobjects/RemoteObjectHostImplTest.java

@@ -77,8 +77,8 @@
     @SmallTest
     @Feature({"AndroidWebView", "Android-JavaBridge"})
     public void testClosesPipeIfObjectDoesNotExist() {
-        RemoteObjectHostImpl host = new RemoteObjectHostImpl(
-                TestJavascriptInterface.class, /* auditor */ null, mRegistry);
+        RemoteObjectHostImpl host = new RemoteObjectHostImpl(TestJavascriptInterface.class,
+                /* auditor */ null, mRegistry, /* allowInspection */ true);
 
         Pair<RemoteObject.Proxy, InterfaceRequest<RemoteObject>> result =
                 RemoteObject.MANAGER.getInterfaceRequest(CoreImpl.getInstance());
@@ -114,8 +114,8 @@
         };
         int id = mRegistry.getObjectId(o);
 
-        RemoteObjectHostImpl host = new RemoteObjectHostImpl(
-                TestJavascriptInterface.class, /* auditor */ null, mRegistry);
+        RemoteObjectHostImpl host = new RemoteObjectHostImpl(TestJavascriptInterface.class,
+                /* auditor */ null, mRegistry, /* allowInspection */ true);
 
         Pair<RemoteObject.Proxy, InterfaceRequest<RemoteObject>> result =
                 RemoteObject.MANAGER.getInterfaceRequest(CoreImpl.getInstance());
@@ -142,8 +142,8 @@
         Object o = new Object();
         int id = mRegistry.getObjectId(o);
 
-        RemoteObjectHostImpl host = new RemoteObjectHostImpl(
-                TestJavascriptInterface.class, /* auditor */ null, mRegistry);
+        RemoteObjectHostImpl host = new RemoteObjectHostImpl(TestJavascriptInterface.class,
+                /* auditor */ null, mRegistry, /* allowInspection */ true);
 
         Assert.assertSame(o, mRegistry.getObjectById(id));
         host.releaseObject(id);
@@ -154,8 +154,8 @@
     @SmallTest
     @Feature({"AndroidWebView", "Android-JavaBridge"})
     public void testClose() {
-        RemoteObjectHostImpl host = new RemoteObjectHostImpl(
-                TestJavascriptInterface.class, /* auditor */ null, mRegistry);
+        RemoteObjectHostImpl host = new RemoteObjectHostImpl(TestJavascriptInterface.class,
+                /* auditor */ null, mRegistry, /* allowInspection */ true);
         Assert.assertThat(mRegistry, isIn(mRetainingSet));
         host.close();
         Assert.assertThat(mRegistry, not(isIn(mRetainingSet)));

diff --git a/content/public/android/junit/src/org/chromium/content/browser/remoteobjects/RemoteObjectImplTest.java b/content/public/android/junit/src/org/chromium/content/browser/remoteobjects/RemoteObjectImplTest.java
index 2b46e38..85fc604 100644
--- a/content/public/android/junit/src/org/chromium/content/browser/remoteobjects/RemoteObjectImplTest.java
+++ b/content/public/android/junit/src/org/chromium/content/browser/remoteobjects/RemoteObjectImplTest.java

@@ -267,6 +267,26 @@
     }
 
     @Test
+    public void testGetMethodsWithDisallowedInspection() {
+        Object target = new Object() {
+            @TestJavascriptInterface
+            public void exposedMethod() {}
+
+            @TestJavascriptInterface
+            public void anotherExposedMethod() {}
+        };
+
+        RemoteObject remoteObject = newRemoteObjectImpl(
+                target, TestJavascriptInterface.class, /* allowInspection */ false);
+
+        // getMethods should be empty.
+        RemoteObject.GetMethodsResponse getMethodsResponse =
+                mock(RemoteObject.GetMethodsResponse.class);
+        remoteObject.getMethods(getMethodsResponse);
+        verify(getMethodsResponse).call(aryEq(new String[] {}));
+    }
+
+    @Test
     public void testObjectGetClassBlocked() {
         Object target = new Object();
         RemoteObject.InvokeMethodResponse response = mock(RemoteObject.InvokeMethodResponse.class);
@@ -871,6 +891,11 @@
 
     private RemoteObjectImpl newRemoteObjectImpl(
             Object target, Class<? extends Annotation> annotation) {
-        return new RemoteObjectImpl(target, annotation, mAuditor, mIdAllocator);
+        return newRemoteObjectImpl(target, annotation, true);
+    }
+
+    private RemoteObjectImpl newRemoteObjectImpl(
+            Object target, Class<? extends Annotation> annotation, boolean allowInspection) {
+        return new RemoteObjectImpl(target, annotation, mAuditor, mIdAllocator, allowInspection);
     }
 }

diff --git a/content/public/browser/web_contents.h b/content/public/browser/web_contents.h
index b31e04d..e282d97 100644
--- a/content/public/browser/web_contents.h
+++ b/content/public/browser/web_contents.h

@@ -43,6 +43,7 @@
 #include "ui/accessibility/ax_mode.h"
 #include "ui/accessibility/ax_tree_update.h"
 #include "ui/base/window_open_disposition.h"
+#include "ui/display/types/display_constants.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/native_widget_types.h"
 
@@ -1037,8 +1038,13 @@
   // Otherwise, if the action should cause fullscreen to be prohibited for a
   // span of time (e.g. a UI element attached to the WebContents), keep the
   // closure alive for that duration.
-  virtual base::ScopedClosureRunner ForSecurityDropFullscreen()
-      WARN_UNUSED_RESULT = 0;
+  //
+  // If |display_id| is valid, only WebContentses on that specific screen will
+  // exit fullscreen; the scoped prohibition will still apply to all displays.
+  // This supports sites using cross-screen window placement capabilities to
+  // retain fullscreen and open or place a window on another screen.
+  virtual base::ScopedClosureRunner ForSecurityDropFullscreen(
+      int64_t display_id = display::kInvalidDisplayId) WARN_UNUSED_RESULT = 0;
 
   // Unblocks requests from renderer for a newly created window. This is
   // used in showCreatedWindow() or sometimes later in cases where

diff --git a/content/renderer/agent_scheduling_group.h b/content/renderer/agent_scheduling_group.h
index 8b2a9a4..de64c9f 100644
--- a/content/renderer/agent_scheduling_group.h
+++ b/content/renderer/agent_scheduling_group.h

@@ -20,7 +20,7 @@
 // and legacy IPC messages.
 class CONTENT_EXPORT AgentSchedulingGroup {
  public:
-  AgentSchedulingGroup();
+  explicit AgentSchedulingGroup();
   ~AgentSchedulingGroup();
 
   AgentSchedulingGroup(const AgentSchedulingGroup&) = delete;

diff --git a/content/renderer/render_thread_impl.cc b/content/renderer/render_thread_impl.cc
index a6118f1..afebe5d 100644
--- a/content/renderer/render_thread_impl.cc
+++ b/content/renderer/render_thread_impl.cc

@@ -74,6 +74,7 @@
 #include "content/public/renderer/content_renderer_client.h"
 #include "content/public/renderer/render_thread_observer.h"
 #include "content/public/renderer/render_view_visitor.h"
+#include "content/renderer/agent_scheduling_group.h"
 #include "content/renderer/browser_exposed_renderer_interfaces.h"
 #include "content/renderer/categorized_worker_pool.h"
 #include "content/renderer/effective_connection_type_helper.h"
@@ -1858,6 +1859,10 @@
       params->has_committed_real_load);
 }
 
+void RenderThreadImpl::CreateAgentSchedulingGroup() {
+  agent_scheduling_groups_.emplace(std::make_unique<AgentSchedulingGroup>());
+}
+
 void RenderThreadImpl::CreateFrameProxy(
     int32_t routing_id,
     int32_t render_view_routing_id,

diff --git a/content/renderer/render_thread_impl.h b/content/renderer/render_thread_impl.h
index 51f5c9d..bb128ce 100644
--- a/content/renderer/render_thread_impl.h
+++ b/content/renderer/render_thread_impl.h

@@ -99,6 +99,7 @@
 }  // namespace viz
 
 namespace content {
+class AgentSchedulingGroup;
 class AudioRendererMixerManager;
 class CategorizedWorkerPool;
 class GpuVideoAcceleratorFactoriesImpl;
@@ -442,6 +443,7 @@
   void CreateView(mojom::CreateViewParamsPtr params) override;
   void DestroyView(int32_t view_id) override;
   void CreateFrame(mojom::CreateFrameParamsPtr params) override;
+  void CreateAgentSchedulingGroup() override;
   void CreateFrameProxy(
       int32_t routing_id,
       int32_t render_view_routing_id,
@@ -614,6 +616,8 @@
 
   mojo::AssociatedRemote<mojom::RenderMessageFilter> render_message_filter_;
 
+  std::set<std::unique_ptr<AgentSchedulingGroup>> agent_scheduling_groups_;
+
   RendererMemoryMetrics purge_and_suspend_memory_metrics_;
   bool needs_to_record_first_active_paint_;
   base::TimeTicks was_backgrounded_time_;

diff --git a/content/test/data/gpu/wait_for_compositing.html b/content/test/data/gpu/wait_for_compositing.html
new file mode 100644
index 0000000..fe6d66fb
--- /dev/null
+++ b/content/test/data/gpu/wait_for_compositing.html

@@ -0,0 +1,38 @@
+<!DOCTYPE HTML>
+
+<!-- READ BEFORE UPDATING:
+If this test is updated make sure to increment the "revision" value of the
+associated test in content/test/gpu/page_sets/pixel_tests.py. This will ensure
+that the baseline images are regenerated on the next run.
+-->
+
+<html>
+<head>
+<meta name="viewport" content="initial-scale=1">
+<title></title>
+<style type="text/css">
+.nomargin {
+  margin: 0px auto;
+}
+</style>
+<script>
+var g_swaps_before_success = 5
+
+function waitForSwapsToComplete() {
+  g_swaps_before_success--;
+  if (g_swaps_before_success > 0) {
+    window.requestAnimationFrame(waitForSwapsToComplete);
+  } else {
+    domAutomationController.send("SUCCESS");
+  }
+}
+
+function main() {
+  window.requestAnimationFrame(waitForSwapsToComplete);
+}
+
+</script>
+</head>
+<body onload="main()">
+</body>
+</html>

diff --git a/content/test/gpu/gpu_tests/common_browser_args.py b/content/test/gpu/gpu_tests/common_browser_args.py
index 0cb3e56..cc35e2e 100644
--- a/content/test/gpu/gpu_tests/common_browser_args.py
+++ b/content/test/gpu/gpu_tests/common_browser_args.py

@@ -10,6 +10,8 @@
     '--disable-device-discovery-notifications'
 DISABLE_DOMAIN_BLOCKING_FOR_3D_APIS = '--disable-domain-blocking-for-3d-apis'
 DISABLE_FEATURES_D3D11_VIDEO_DECODER = '--disable-features=D3D11VideoDecoder'
+DISABLE_FORCE_FULL_DAMAGE =\
+    '--disable-features=DirectCompositionForceFullDamage'
 DISABLE_GPU = '--disable-gpu'
 DISABLE_GPU_COMPOSITING = '--disable-gpu-compositing'
 DISABLE_GPU_PROCESS_CRASH_LIMIT = '--disable-gpu-process-crash-limit'
@@ -19,6 +21,7 @@
 DISABLE_VP_SCALING = '--disable_vp_scaling=1'
 ENABLE_EXPERIMENTAL_WEB_PLATFORM_FEATURES =\
     '--enable-experimental-web-platform-features'
+ENABLE_FORCE_FULL_DAMAGE = "--direct-composition-force-full-damage-for-testing"
 ENABLE_GPU_BENCHMARKING = '--enable-gpu-benchmarking'
 ENSURE_FORCED_COLOR_PROFILE = '--ensure-forced-color-profile'
 FORCE_COLOR_PROFILE_SRGB = '--force-color-profile=srgb'

diff --git a/content/test/gpu/gpu_tests/pixel_test_pages.py b/content/test/gpu/gpu_tests/pixel_test_pages.py
index dab5f06..6f7bff6b 100644
--- a/content/test/gpu/gpu_tests/pixel_test_pages.py
+++ b/content/test/gpu/gpu_tests/pixel_test_pages.py

@@ -799,3 +799,18 @@
             test_rect=[0, 0, 300, 300],
             browser_args=['--force-color-profile=hdr10']),
     ]
+
+  @staticmethod
+  def ForceFullDamagePages(base_name):
+    return [
+        PixelTestPage('wait_for_compositing.html',
+                      base_name + '_ForceFullDamage',
+                      test_rect=[0, 0, 0, 0],
+                      other_args={'full_damage': True},
+                      browser_args=[cba.ENABLE_FORCE_FULL_DAMAGE]),
+        PixelTestPage('wait_for_compositing.html',
+                      base_name + '_ForcePartialDamage',
+                      test_rect=[0, 0, 0, 0],
+                      other_args={'full_damage': False},
+                      browser_args=[cba.DISABLE_FORCE_FULL_DAMAGE]),
+    ]

diff --git a/content/test/gpu/gpu_tests/trace_integration_test.py b/content/test/gpu/gpu_tests/trace_integration_test.py
index 26c1aa0..3e63d4a8 100644
--- a/content/test/gpu/gpu_tests/trace_integration_test.py
+++ b/content/test/gpu/gpu_tests/trace_integration_test.py

@@ -85,6 +85,8 @@
 _GET_STATISTICS_EVENT_NAME = 'GetFrameStatisticsMedia'
 _SWAP_CHAIN_PRESENT_EVENT_NAME = 'SwapChain::Present'
 _PRESENT_TO_SWAP_CHAIN_EVENT_NAME = 'SwapChainPresenter::PresentToSwapChain'
+_PRESENT_MAIN_SWAP_CHAIN_EVENT_NAME =\
+    'DirectCompositionChildSurfaceWin::PresentSwapChain'
 
 
 class _TraceTestArguments(object):
@@ -168,6 +170,15 @@
                  finish_js_condition='domAutomationController._finished',
                  success_eval_func='CheckOverlayMode',
                  other_args=p.other_args))
+    for p in namespace.ForceFullDamagePages('SwapChainTraceTest'):
+      yield (p.name, gpu_relative_path + p.url,
+             _TraceTestArguments(
+                 browser_args=p.browser_args,
+                 category='gpu',
+                 test_harness_script=basic_test_harness_script,
+                 finish_js_condition='domAutomationController._finished',
+                 success_eval_func='CheckMainSwapChainPath',
+                 other_args=p.other_args))
 
   def RunActualGpuTest(self, test_path, *args):
     test_params = args[0]
@@ -445,8 +456,45 @@
       if presentation_mode == 'swap chain':
         break
     else:
-      self.fail(
-          'Events with name %s were not found' % _SWAP_CHAIN_PRESENT_EVENT_NAME)
+      self.fail('Events with name %s were not found' %
+                _PRESENT_TO_SWAP_CHAIN_EVENT_NAME)
+
+  def _EvaluateSuccess_CheckMainSwapChainPath(self, category, event_iterator,
+                                              other_args):
+    """Verified that Chrome's main swap chain is presented with full damage."""
+    os_name = self.browser.platform.GetOSName()
+    assert os_name and os_name.lower() == 'win'
+
+    overlay_bot_config = self.GetOverlayBotConfig()
+    if overlay_bot_config is None:
+      self.fail('Overlay bot config can not be determined')
+    assert overlay_bot_config.get('direct_composition', False)
+
+    expect_full_damage = other_args and other_args.get('full_damage', False)
+
+    partial_damage_encountered = False
+    full_damage_encountered = False
+    # Verify expectations through captured trace events.
+    for event in event_iterator:
+      if event.category != category:
+        continue
+      if event.name != _PRESENT_MAIN_SWAP_CHAIN_EVENT_NAME:
+        continue
+      dirty_rect = event.args.get('dirty_rect', None)
+      if dirty_rect is None:
+        continue
+      if dirty_rect == 'full_damage':
+        full_damage_encountered = True
+      else:
+        partial_damage_encountered = True
+
+    # Today Chrome either run with full damage or partial damage, but not both.
+    # This may change in the future.
+    if (expect_full_damage != full_damage_encountered
+        or expect_full_damage == partial_damage_encountered):
+      self.fail('Expected events with name %s of %s, got others' %
+                (_PRESENT_MAIN_SWAP_CHAIN_EVENT_NAME,
+                 'full damage' if expect_full_damage else 'partial damage'))
 
   @classmethod
   def ExpectationsFiles(cls):

diff --git a/content/test/test_render_view_host_factory.cc b/content/test/test_render_view_host_factory.cc
index 9b59b72..8ced690 100644
--- a/content/test/test_render_view_host_factory.cc
+++ b/content/test/test_render_view_host_factory.cc

@@ -40,8 +40,10 @@
     bool swapped_out) {
   return new TestRenderViewHost(
       instance,
-      TestRenderWidgetHost::Create(widget_delegate, instance->GetProcess(),
-                                   widget_routing_id, false),
+      TestRenderWidgetHost::Create(
+          widget_delegate,
+          static_cast<SiteInstanceImpl*>(instance)->GetAgentSchedulingGroup(),
+          widget_routing_id, false),
       delegate, routing_id, main_frame_routing_id, swapped_out);
 }
 

diff --git a/content/test/test_render_widget_host.cc b/content/test/test_render_widget_host.cc
index 7f834c6..f2940a9f 100644
--- a/content/test/test_render_widget_host.cc
+++ b/content/test/test_render_widget_host.cc

@@ -13,19 +13,20 @@
 
 std::unique_ptr<RenderWidgetHostImpl> TestRenderWidgetHost::Create(
     RenderWidgetHostDelegate* delegate,
-    RenderProcessHost* process,
+    AgentSchedulingGroupHost& agent_scheduling_group,
     int32_t routing_id,
     bool hidden) {
-  return base::WrapUnique(
-      new TestRenderWidgetHost(delegate, process, routing_id, hidden));
+  return base::WrapUnique(new TestRenderWidgetHost(
+      delegate, agent_scheduling_group, routing_id, hidden));
 }
 
-TestRenderWidgetHost::TestRenderWidgetHost(RenderWidgetHostDelegate* delegate,
-                                           RenderProcessHost* process,
-                                           int32_t routing_id,
-                                           bool hidden)
+TestRenderWidgetHost::TestRenderWidgetHost(
+    RenderWidgetHostDelegate* delegate,
+    AgentSchedulingGroupHost& agent_scheduling_group,
+    int32_t routing_id,
+    bool hidden)
     : RenderWidgetHostImpl(delegate,
-                           process,
+                           agent_scheduling_group,
                            routing_id,
                            hidden,
                            std::make_unique<FrameTokenMessageQueue>()) {

diff --git a/content/test/test_render_widget_host.h b/content/test/test_render_widget_host.h
index 13fbe11..15a8ce16 100644
--- a/content/test/test_render_widget_host.h
+++ b/content/test/test_render_widget_host.h

@@ -18,7 +18,7 @@
  public:
   static std::unique_ptr<RenderWidgetHostImpl> Create(
       RenderWidgetHostDelegate* delegate,
-      RenderProcessHost* process,
+      AgentSchedulingGroupHost& agent_scheduling_group,
       int32_t routing_id,
       bool hidden);
   ~TestRenderWidgetHost() override;
@@ -30,7 +30,7 @@
 
  private:
   TestRenderWidgetHost(RenderWidgetHostDelegate* delegate,
-                       RenderProcessHost* process,
+                       AgentSchedulingGroupHost& agent_scheduling_group,
                        int32_t routing_id,
                        bool hidden);
   MockWidgetInputHandler input_handler_;

diff --git a/content/test/test_render_widget_host_factory.cc b/content/test/test_render_widget_host_factory.cc
index 71106e4b..1b75646 100644
--- a/content/test/test_render_widget_host_factory.cc
+++ b/content/test/test_render_widget_host_factory.cc

@@ -19,10 +19,11 @@
 std::unique_ptr<RenderWidgetHostImpl>
 TestRenderWidgetHostFactory::CreateRenderWidgetHost(
     RenderWidgetHostDelegate* delegate,
-    RenderProcessHost* process,
+    AgentSchedulingGroupHost& agent_scheduling_group,
     int32_t routing_id,
     bool hidden) {
-  return TestRenderWidgetHost::Create(delegate, process, routing_id, hidden);
+  return TestRenderWidgetHost::Create(delegate, agent_scheduling_group,
+                                      routing_id, hidden);
 }
 
 }  // namespace content

diff --git a/content/test/test_render_widget_host_factory.h b/content/test/test_render_widget_host_factory.h
index bf49da9..5dc5bf7b 100644
--- a/content/test/test_render_widget_host_factory.h
+++ b/content/test/test_render_widget_host_factory.h

@@ -25,7 +25,7 @@
 
   std::unique_ptr<RenderWidgetHostImpl> CreateRenderWidgetHost(
       RenderWidgetHostDelegate* delegate,
-      RenderProcessHost* process,
+      AgentSchedulingGroupHost& agent_scheduling_group,
       int32_t routing_id,
       bool hidden) override;
 

diff --git a/content/test/test_web_contents.cc b/content/test/test_web_contents.cc
index 1962a12..3bd2127 100644
--- a/content/test/test_web_contents.cc
+++ b/content/test/test_web_contents.cc

@@ -398,13 +398,13 @@
 }
 
 void TestWebContents::CreateNewWidget(
-    int32_t render_process_id,
+    AgentSchedulingGroupHost& agent_scheduling_group,
     int32_t route_id,
     mojo::PendingAssociatedReceiver<blink::mojom::WidgetHost> blink_widget_host,
     mojo::PendingAssociatedRemote<blink::mojom::Widget> blink_widget) {}
 
 void TestWebContents::CreateNewFullscreenWidget(
-    int32_t render_process_id,
+    AgentSchedulingGroupHost& agent_scheduling_group,
     int32_t route_id,
     mojo::PendingAssociatedReceiver<blink::mojom::WidgetHost> blink_widget_host,
     mojo::PendingAssociatedRemote<blink::mojom::Widget> blink_widget) {}

diff --git a/content/test/test_web_contents.h b/content/test/test_web_contents.h
index 8c9e311..9d6afb4 100644
--- a/content/test/test_web_contents.h
+++ b/content/test/test_web_contents.h

@@ -16,6 +16,7 @@
 
 #include "base/optional.h"
 #include "base/unguessable_token.h"
+#include "content/browser/site_instance_impl.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/public/test/web_contents_tester.h"
 #include "content/test/test_render_frame_host.h"
@@ -185,14 +186,14 @@
       bool is_new_browsing_instance,
       bool has_user_gesture,
       SessionStorageNamespace* session_storage_namespace) override;
-  void CreateNewWidget(int32_t render_process_id,
+  void CreateNewWidget(AgentSchedulingGroupHost& agent_scheduling_group,
                        int32_t route_id,
                        mojo::PendingAssociatedReceiver<blink::mojom::WidgetHost>
                            blink_widget_host,
                        mojo::PendingAssociatedRemote<blink::mojom::Widget>
                            blink_widget) override;
   void CreateNewFullscreenWidget(
-      int32_t render_process_id,
+      AgentSchedulingGroupHost& agent_scheduling_group,
       int32_t route_id,
       mojo::PendingAssociatedReceiver<blink::mojom::WidgetHost>
           blink_widget_host,

diff --git a/device/bluetooth/adapter.cc b/device/bluetooth/adapter.cc
index dad05519..4ff570e 100644
--- a/device/bluetooth/adapter.cc
+++ b/device/bluetooth/adapter.cc

@@ -20,6 +20,7 @@
 #include "device/bluetooth/server_socket.h"
 #include "device/bluetooth/socket.h"
 #include "mojo/public/cpp/bindings/pending_remote.h"
+#include "mojo/public/cpp/bindings/remote.h"
 #include "mojo/public/cpp/bindings/self_owned_receiver.h"
 
 namespace bluetooth {
@@ -79,9 +80,9 @@
   std::move(callback).Run(std::move(adapter_info));
 }
 
-void Adapter::SetClient(mojo::PendingRemote<mojom::AdapterClient> client,
-                        SetClientCallback callback) {
-  client_.Bind(std::move(client));
+void Adapter::AddObserver(mojo::PendingRemote<mojom::AdapterObserver> observer,
+                          AddObserverCallback callback) {
+  observers_.Add(std::move(observer));
   std::move(callback).Run();
 }
 
@@ -132,7 +133,7 @@
                                   const device::BluetoothUUID& service_uuid,
                                   CreateRfcommServiceCallback callback) {
   device::BluetoothAdapter::ServiceOptions service_options;
-  service_options.name = std::make_unique<std::string>(service_name);
+  service_options.name = service_name;
 
   auto copyable_callback = base::AdaptCallbackForRepeating(std::move(callback));
   adapter_->CreateRfcommService(
@@ -145,50 +146,47 @@
 
 void Adapter::AdapterPresentChanged(device::BluetoothAdapter* adapter,
                                     bool present) {
-  if (client_)
-    client_->PresentChanged(present);
+  for (auto& observer : observers_)
+    observer->PresentChanged(present);
 }
 
 void Adapter::AdapterPoweredChanged(device::BluetoothAdapter* adapter,
                                     bool powered) {
-  if (client_)
-    client_->PoweredChanged(powered);
+  for (auto& observer : observers_)
+    observer->PoweredChanged(powered);
 }
 
 void Adapter::AdapterDiscoverableChanged(device::BluetoothAdapter* adapter,
                                          bool discoverable) {
-  if (client_)
-    client_->DiscoverableChanged(discoverable);
+  for (auto& observer : observers_)
+    observer->DiscoverableChanged(discoverable);
 }
 
 void Adapter::AdapterDiscoveringChanged(device::BluetoothAdapter* adapter,
                                         bool discovering) {
-  if (client_)
-    client_->DiscoveringChanged(discovering);
+  for (auto& observer : observers_)
+    observer->DiscoveringChanged(discovering);
 }
 
 void Adapter::DeviceAdded(device::BluetoothAdapter* adapter,
                           device::BluetoothDevice* device) {
-  if (client_) {
-    auto device_info = Device::ConstructDeviceInfoStruct(device);
-    client_->DeviceAdded(std::move(device_info));
-  }
+  auto device_info = Device::ConstructDeviceInfoStruct(device);
+  for (auto& observer : observers_)
+    observer->DeviceAdded(device_info->Clone());
 }
 
 void Adapter::DeviceChanged(device::BluetoothAdapter* adapter,
                             device::BluetoothDevice* device) {
-  if (client_) {
-    auto device_info = Device::ConstructDeviceInfoStruct(device);
-    client_->DeviceChanged(std::move(device_info));
-  }
+  auto device_info = Device::ConstructDeviceInfoStruct(device);
+  for (auto& observer : observers_)
+    observer->DeviceChanged(device_info->Clone());
 }
 
 void Adapter::DeviceRemoved(device::BluetoothAdapter* adapter,
                             device::BluetoothDevice* device) {
-  if (client_) {
-    auto device_info = Device::ConstructDeviceInfoStruct(device);
-    client_->DeviceRemoved(std::move(device_info));
-  }
+  auto device_info = Device::ConstructDeviceInfoStruct(device);
+  for (auto& observer : observers_)
+    observer->DeviceRemoved(device_info->Clone());
 }
 
 void Adapter::OnGattConnected(

diff --git a/device/bluetooth/adapter.h b/device/bluetooth/adapter.h
index 329f95a..196ff885 100644
--- a/device/bluetooth/adapter.h
+++ b/device/bluetooth/adapter.h

@@ -16,7 +16,7 @@
 #include "device/bluetooth/public/mojom/adapter.mojom.h"
 #include "device/bluetooth/public/mojom/device.mojom-forward.h"
 #include "mojo/public/cpp/bindings/pending_remote.h"
-#include "mojo/public/cpp/bindings/remote.h"
+#include "mojo/public/cpp/bindings/remote_set.h"
 
 namespace bluetooth {
 
@@ -35,8 +35,8 @@
                        ConnectToDeviceCallback callback) override;
   void GetDevices(GetDevicesCallback callback) override;
   void GetInfo(GetInfoCallback callback) override;
-  void SetClient(mojo::PendingRemote<mojom::AdapterClient> client,
-                 SetClientCallback callback) override;
+  void AddObserver(mojo::PendingRemote<mojom::AdapterObserver> observer,
+                   AddObserverCallback callback) override;
   void SetDiscoverable(bool discoverable,
                        SetDiscoverableCallback callback) override;
   void SetName(const std::string& name, SetNameCallback callback) override;
@@ -98,8 +98,8 @@
   // The current Bluetooth adapter.
   scoped_refptr<device::BluetoothAdapter> adapter_;
 
-  // The adapter client that listens to this service.
-  mojo::Remote<mojom::AdapterClient> client_;
+  // The adapter observers that listen to this service.
+  mojo::RemoteSet<mojom::AdapterObserver> observers_;
 
   base::WeakPtrFactory<Adapter> weak_ptr_factory_{this};
 

diff --git a/device/bluetooth/bluetooth_adapter.h b/device/bluetooth/bluetooth_adapter.h
index 415c01c7..16e00340 100644
--- a/device/bluetooth/bluetooth_adapter.h
+++ b/device/bluetooth/bluetooth_adapter.h

@@ -19,6 +19,7 @@
 #include "base/containers/queue.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
+#include "base/optional.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "device/bluetooth/bluetooth_advertisement.h"
@@ -311,9 +312,9 @@
     ServiceOptions();
     ~ServiceOptions();
 
-    std::unique_ptr<int> channel;
-    std::unique_ptr<int> psm;
-    std::unique_ptr<std::string> name;
+    base::Optional<int> channel;
+    base::Optional<int> psm;
+    base::Optional<std::string> name;
   };
 
   // The ErrorCallback is used for methods that can fail in which case it is

diff --git a/device/bluetooth/bluetooth_socket_mac.mm b/device/bluetooth/bluetooth_socket_mac.mm
index 8bf819d4..7a73cf8 100644
--- a/device/bluetooth/bluetooth_socket_mac.mm
+++ b/device/bluetooth/bluetooth_socket_mac.mm

@@ -20,6 +20,7 @@
 #include "base/mac/scoped_cftyperef.h"
 #include "base/memory/ref_counted.h"
 #include "base/numerics/safe_conversions.h"
+#include "base/optional.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/sys_string_conversions.h"
@@ -245,7 +246,7 @@
 // corresponding to the provided |uuid|, |name|, and |protocol_definition|. Does
 // not include a service name in the definition if |name| is null.
 NSDictionary* BuildServiceDefinition(const BluetoothUUID& uuid,
-                                     const std::string* name,
+                                     const base::Optional<std::string>& name,
                                      NSArray* protocol_definition) {
   NSMutableDictionary* service_definition = [NSMutableDictionary dictionary];
 
@@ -290,8 +291,7 @@
       },
     ],
   ];
-  return BuildServiceDefinition(
-      uuid, options.name.get(), rfcomm_protocol_definition);
+  return BuildServiceDefinition(uuid, options.name, rfcomm_protocol_definition);
 }
 
 // Returns a dictionary containing the Bluetooth L2CAP service definition
@@ -310,8 +310,7 @@
       },
     ],
   ];
-  return BuildServiceDefinition(
-      uuid, options.name.get(), l2cap_protocol_definition);
+  return BuildServiceDefinition(uuid, options.name, l2cap_protocol_definition);
 }
 
 // Registers a Bluetooth service with the specified |service_definition| in the
@@ -340,7 +339,7 @@
 // Returns true iff the |requested_channel_id| was registered in the RFCOMM
 // |service_record|. If it was, also updates |registered_channel_id| with the
 // registered value, as the requested id may have been left unspecified.
-bool VerifyRfcommService(const int* requested_channel_id,
+bool VerifyRfcommService(const base::Optional<int>& requested_channel_id,
                          BluetoothRFCOMMChannelID* registered_channel_id,
                          IOBluetoothSDPServiceRecord* service_record) {
   // Test whether the requested channel id was available.
@@ -357,9 +356,9 @@
   return true;
 }
 
-// Registers an RFCOMM service with the specified |uuid|, |options.channel_id|,
+// Registers an RFCOMM service with the specified |uuid|, |options.channel|,
 // and |options.name| in the system SDP server. Automatically allocates a
-// channel if |options.channel_id| is null. Does not specify a name if
+// channel if |options.channel| is null. Does not specify a name if
 // |options.name| is null. Returns a handle to the registered service and
 // updates |registered_channel_id| to the actual channel id, or returns nil if
 // the service could not be registered.
@@ -369,14 +368,14 @@
     BluetoothRFCOMMChannelID* registered_channel_id) {
   return RegisterService(
       BuildRfcommServiceDefinition(uuid, options),
-      base::BindOnce(&VerifyRfcommService, options.channel.get(),
+      base::BindOnce(&VerifyRfcommService, options.channel,
                      registered_channel_id));
 }
 
 // Returns true iff the |requested_psm| was registered in the L2CAP
 // |service_record|. If it was, also updates |registered_psm| with the
 // registered value, as the requested PSM may have been left unspecified.
-bool VerifyL2capService(const int* requested_psm,
+bool VerifyL2capService(const base::Optional<int>& requested_psm,
                         BluetoothL2CAPPSM* registered_psm,
                         IOBluetoothSDPServiceRecord* service_record) {
   // Test whether the requested PSM was available.
@@ -404,7 +403,7 @@
     BluetoothL2CAPPSM* registered_psm) {
   return RegisterService(
       BuildL2capServiceDefinition(uuid, options),
-      base::BindOnce(&VerifyL2capService, options.psm.get(), registered_psm));
+      base::BindOnce(&VerifyL2capService, options.psm, registered_psm));
 }
 
 }  // namespace

diff --git a/device/bluetooth/public/mojom/adapter.mojom b/device/bluetooth/public/mojom/adapter.mojom
index c21d290..24a9ab1 100644
--- a/device/bluetooth/public/mojom/adapter.mojom
+++ b/device/bluetooth/public/mojom/adapter.mojom

@@ -124,9 +124,9 @@
   [Sync]
   GetInfo() => (AdapterInfo info);
 
-  // Sets the client that listens for the adapter's events.
+  // Adds an observer that listens for the adapter's events.
   [Sync]
-  SetClient(pending_remote<AdapterClient> client) => ();
+  AddObserver(pending_remote<AdapterObserver> observer) => ();
 
   // Requests the local device to make itself discoverable to nearby remote
   // devices.
@@ -164,7 +164,8 @@
       => (pending_remote<ServerSocket>? server_socket);
 };
 
-interface AdapterClient {
+// Listener on Bluetooth events. Register as an observer via AddObserver().
+interface AdapterObserver {
   // Called when the presence of the adapter changes.
   PresentChanged(bool present);
 

diff --git a/extensions/browser/api/bluetooth_socket/bluetooth_socket_api.cc b/extensions/browser/api/bluetooth_socket/bluetooth_socket_api.cc
index 742e183..89b82bfb 100644
--- a/extensions/browser/api/bluetooth_socket/bluetooth_socket_api.cc
+++ b/extensions/browser/api/bluetooth_socket/bluetooth_socket_api.cc

@@ -276,12 +276,12 @@
     return;
   }
 
-  std::unique_ptr<std::string> name;
+  base::Optional<std::string> name;
   if (socket->name())
-    name.reset(new std::string(*socket->name()));
+    name = *socket->name();
 
   CreateService(
-      adapter, bluetooth_uuid, std::move(name),
+      adapter, bluetooth_uuid, name,
       base::BindOnce(&BluetoothSocketListenFunction::OnCreateService, this),
       base::BindOnce(&BluetoothSocketListenFunction::OnCreateServiceError,
                      this));
@@ -334,17 +334,15 @@
 void BluetoothSocketListenUsingRfcommFunction::CreateService(
     scoped_refptr<device::BluetoothAdapter> adapter,
     const device::BluetoothUUID& uuid,
-    std::unique_ptr<std::string> name,
+    const base::Optional<std::string>& name,
     device::BluetoothAdapter::CreateServiceCallback callback,
     device::BluetoothAdapter::CreateServiceErrorCallback error_callback) {
   device::BluetoothAdapter::ServiceOptions service_options;
   service_options.name = std::move(name);
 
   ListenOptions* options = params_->options.get();
-  if (options) {
-    if (options->channel.get())
-      service_options.channel.reset(new int(*(options->channel)));
-  }
+  if (options && options->channel.get())
+    service_options.channel = *options->channel;
 
   adapter->CreateRfcommService(uuid, service_options, std::move(callback),
                                std::move(error_callback));
@@ -377,23 +375,21 @@
 void BluetoothSocketListenUsingL2capFunction::CreateService(
     scoped_refptr<device::BluetoothAdapter> adapter,
     const device::BluetoothUUID& uuid,
-    std::unique_ptr<std::string> name,
+    const base::Optional<std::string>& name,
     device::BluetoothAdapter::CreateServiceCallback callback,
     device::BluetoothAdapter::CreateServiceErrorCallback error_callback) {
   device::BluetoothAdapter::ServiceOptions service_options;
   service_options.name = std::move(name);
 
   ListenOptions* options = params_->options.get();
-  if (options) {
-    if (options->psm) {
-      int psm = *options->psm;
-      if (!IsValidPsm(psm)) {
-        std::move(error_callback).Run(kInvalidPsmError);
-        return;
-      }
-
-      service_options.psm.reset(new int(psm));
+  if (options && options->psm) {
+    int psm = *options->psm;
+    if (!IsValidPsm(psm)) {
+      std::move(error_callback).Run(kInvalidPsmError);
+      return;
     }
+
+    service_options.psm = psm;
   }
 
   adapter->CreateL2capService(uuid, service_options, std::move(callback),

diff --git a/extensions/browser/api/bluetooth_socket/bluetooth_socket_api.h b/extensions/browser/api/bluetooth_socket/bluetooth_socket_api.h
index 7228780..3bbcf2e 100644
--- a/extensions/browser/api/bluetooth_socket/bluetooth_socket_api.h
+++ b/extensions/browser/api/bluetooth_socket/bluetooth_socket_api.h

@@ -12,6 +12,7 @@
 #include <unordered_set>
 
 #include "base/memory/ref_counted.h"
+#include "base/optional.h"
 #include "content/public/browser/browser_thread.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "extensions/browser/api/api_resource_manager.h"
@@ -117,7 +118,7 @@
   virtual void CreateService(
       scoped_refptr<device::BluetoothAdapter> adapter,
       const device::BluetoothUUID& uuid,
-      std::unique_ptr<std::string> name,
+      const base::Optional<std::string>& name,
       device::BluetoothAdapter::CreateServiceCallback callback,
       device::BluetoothAdapter::CreateServiceErrorCallback error_callback) = 0;
   virtual std::unique_ptr<base::ListValue> CreateResults() = 0;
@@ -154,7 +155,7 @@
   bool CreateParams() override;
   void CreateService(scoped_refptr<device::BluetoothAdapter> adapter,
                      const device::BluetoothUUID& uuid,
-                     std::unique_ptr<std::string> name,
+                     const base::Optional<std::string>& name,
                      device::BluetoothAdapter::CreateServiceCallback callback,
                      device::BluetoothAdapter::CreateServiceErrorCallback
                          error_callback) override;
@@ -182,7 +183,7 @@
   bool CreateParams() override;
   void CreateService(scoped_refptr<device::BluetoothAdapter> adapter,
                      const device::BluetoothUUID& uuid,
-                     std::unique_ptr<std::string> name,
+                     const base::Optional<std::string>& name,
                      device::BluetoothAdapter::CreateServiceCallback callback,
                      device::BluetoothAdapter::CreateServiceErrorCallback
                          error_callback) override;

diff --git a/extensions/browser/api/bluetooth_socket/bluetooth_socket_apitest.cc b/extensions/browser/api/bluetooth_socket/bluetooth_socket_apitest.cc
index d2a18c4..e228195 100644
--- a/extensions/browser/api/bluetooth_socket/bluetooth_socket_apitest.cc
+++ b/extensions/browser/api/bluetooth_socket/bluetooth_socket_apitest.cc

@@ -128,13 +128,13 @@
   scoped_refptr<testing::StrictMock<MockBluetoothSocket> > mock_server_socket
       = new testing::StrictMock<MockBluetoothSocket>();
   BluetoothAdapter::ServiceOptions service_options;
-  service_options.name.reset(new std::string("MyServiceName"));
+  service_options.name = "MyServiceName";
   EXPECT_CALL(
       *mock_adapter_,
       CreateRfcommService(
           service_uuid,
           testing::Field(&BluetoothAdapter::ServiceOptions::name,
-                         testing::Pointee(testing::Eq("MyServiceName"))),
+                         testing::Eq("MyServiceName")),
           testing::_, testing::_))
       .WillOnce(base::test::RunOnceCallback<2>(mock_server_socket));
 

diff --git a/extensions/browser/api/clipboard/clipboard_api.h b/extensions/browser/api/clipboard/clipboard_api.h
index 67b2726..2fe12fc 100644
--- a/extensions/browser/api/clipboard/clipboard_api.h
+++ b/extensions/browser/api/clipboard/clipboard_api.h

@@ -7,6 +7,7 @@
 
 #include <vector>
 
+#include "build/build_config.h"
 #include "extensions/browser/browser_context_keyed_api_factory.h"
 #include "extensions/browser/extension_function.h"
 #include "extensions/common/api/clipboard.h"
@@ -27,6 +28,9 @@
 
   // ui::ClipboardObserver implementation.
   void OnClipboardDataChanged() override;
+#if defined(OS_CHROMEOS)
+  void OnClipboardDataRead() override {}
+#endif
 
  private:
   friend class BrowserContextKeyedAPIFactory<ClipboardAPI>;

diff --git a/gpu/ipc/common/gpu_memory_buffer_support.h b/gpu/ipc/common/gpu_memory_buffer_support.h
index 2999e94..29419a24 100644
--- a/gpu/ipc/common/gpu_memory_buffer_support.h
+++ b/gpu/ipc/common/gpu_memory_buffer_support.h

@@ -16,7 +16,7 @@
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/gpu_memory_buffer.h"
 
-#if defined(OS_LINUX) || defined(USE_OZONE)
+#if defined(OS_LINUX) || defined(OS_CHROMEOS) || defined(USE_OZONE)
 namespace gfx {
 class ClientNativePixmapFactory;
 }
@@ -38,7 +38,7 @@
   bool IsNativeGpuMemoryBufferConfigurationSupported(gfx::BufferFormat format,
                                                      gfx::BufferUsage usage);
 
-#if defined(OS_LINUX) || defined(USE_OZONE)
+#if defined(OS_LINUX) || defined(OS_CHROMEOS) || defined(USE_OZONE)
   gfx::ClientNativePixmapFactory* client_native_pixmap_factory() {
     return client_native_pixmap_factory_.get();
   }
@@ -62,7 +62,7 @@
       GpuMemoryBufferImpl::DestructionCallback callback);
 
  private:
-#if defined(OS_LINUX) || defined(USE_OZONE)
+#if defined(OS_LINUX) || defined(OS_CHROMEOS) || defined(USE_OZONE)
   std::unique_ptr<gfx::ClientNativePixmapFactory> client_native_pixmap_factory_;
 #endif
 

diff --git a/gpu/vulkan/init/gr_vk_memory_allocator_impl.cc b/gpu/vulkan/init/gr_vk_memory_allocator_impl.cc
index 0a900d0..91d0dd1 100644
--- a/gpu/vulkan/init/gr_vk_memory_allocator_impl.cc
+++ b/gpu/vulkan/init/gr_vk_memory_allocator_impl.cc

@@ -6,6 +6,7 @@
 
 #include <vk_mem_alloc.h>
 
+#include "base/feature_list.h"
 #include "base/trace_event/trace_event.h"
 #include "gpu/vulkan/vma_wrapper.h"
 #include "gpu/vulkan/vulkan_device_queue.h"
@@ -14,6 +15,9 @@
 
 namespace {
 
+const base::Feature kCpuWritesGpuReadsCached{"CpuWritesGpuReadsCached",
+                                             base::FEATURE_ENABLED_BY_DEFAULT};
+
 class GrVkMemoryAllocatorImpl : public GrVkMemoryAllocator {
  public:
   explicit GrVkMemoryAllocatorImpl(VmaAllocator allocator)
@@ -82,9 +86,10 @@
         info.preferredFlags = VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
         break;
       case BufferUsage::kCpuWritesGpuReads:
-        // First attempt to try memory is also cached
-        info.requiredFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
-                             VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
+        info.requiredFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
+        if (base::FeatureList::IsEnabled(kCpuWritesGpuReadsCached))
+          info.requiredFlags |= VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
+
         info.preferredFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
         break;
       case BufferUsage::kGpuWritesCpuReads:
@@ -217,4 +222,4 @@
   return sk_make_sp<GrVkMemoryAllocatorImpl>(device_queue->vma_allocator());
 }
 
-}  // namespace gpu
\ No newline at end of file
+}  // namespace gpu

diff --git a/infra/config/generated/commit-queue.cfg b/infra/config/generated/commit-queue.cfg
index e727dbc..802cca1 100644
--- a/infra/config/generated/commit-queue.cfg
+++ b/infra/config/generated/commit-queue.cfg

@@ -1251,7 +1251,7 @@
       }
       builders {
         name: "chromium/try/mac-coverage-rel"
-        experiment_percentage: 3
+        experiment_percentage: 5
         location_regexp: ".*"
         location_regexp_exclude: ".+/[+]/docs/.+"
         location_regexp_exclude: ".+/[+]/infra/config/.+"

diff --git a/infra/config/generated/cq-builders.md b/infra/config/generated/cq-builders.md
index 883a50ad..25dfdf6 100644
--- a/infra/config/generated/cq-builders.md
+++ b/infra/config/generated/cq-builders.md

@@ -363,5 +363,5 @@
   * [`//services/tracing/.+`](https://cs.chromium.org/chromium/src/services/tracing/)
 
 * [mac-coverage-rel](https://ci.chromium.org/p/chromium/builders/try/mac-coverage-rel) ([definition](https://cs.chromium.org/search?q=package:%5Echromium$+file:/cq.star$+-file:/beta/+-file:/stable/+mac-coverage-rel)) ([matching builders](https://cs.chromium.org/search?q=+file:trybots.py+mac-coverage-rel))
-  * Experiment percentage: 3
+  * Experiment percentage: 5
 

diff --git a/infra/config/generated/cr-buildbucket.cfg b/infra/config/generated/cr-buildbucket.cfg
index 2e6f86d..a204a49f 100644
--- a/infra/config/generated/cr-buildbucket.cfg
+++ b/infra/config/generated/cr-buildbucket.cfg

@@ -10458,7 +10458,7 @@
         cmd: "recipes"
       }
       properties: "{\"$build/chromium_tests\":{\"bucketed_triggers\":true},\"$build/goma\":{\"enable_ats\":true,\"rpc_extra_params\":\"?prod\",\"server_host\":\"goma.chromium.org\"},\"$kitchen\":{\"devshell\":true,\"git_auth\":true},\"mastername\":\"chromium.chromiumos\",\"recipe\":\"chromium\"}"
-      execution_timeout_secs: 10800
+      execution_timeout_secs: 14400
       build_numbers: YES
       service_account: "chromium-ci-builder@chops-service-accounts.iam.gserviceaccount.com"
       resultdb {

diff --git a/infra/config/subprojects/chromium/ci.star b/infra/config/subprojects/chromium/ci.star
index eb07e2e..c75e65d 100644
--- a/infra/config/subprojects/chromium/ci.star
+++ b/infra/config/subprojects/chromium/ci.star

@@ -624,6 +624,7 @@
         short_name = "rel",
     ),
     main_console_view = settings.main_console_name,
+    execution_timeout = 4 * time.hour,
 )
 
 ci.chromiumos_builder(

diff --git a/infra/config/subprojects/chromium/master-only/try.star b/infra/config/subprojects/chromium/master-only/try.star
index 83347d7..6d9c96e 100644
--- a/infra/config/subprojects/chromium/master-only/try.star
+++ b/infra/config/subprojects/chromium/master-only/try.star

@@ -509,7 +509,7 @@
     name = "mac-coverage-rel",
     use_clang_coverage = True,
     goma_jobs = goma.jobs.J150,
-    tryjob = try_.job(experiment_percentage = 3),
+    tryjob = try_.job(experiment_percentage = 5),
 )
 
 try_.chromium_mac_builder(

diff --git a/ios/chrome/browser/autofill/form_input_egtest.mm b/ios/chrome/browser/autofill/form_input_egtest.mm
index c6320440..13e0e15 100644
--- a/ios/chrome/browser/autofill/form_input_egtest.mm
+++ b/ios/chrome/browser/autofill/form_input_egtest.mm

@@ -74,7 +74,6 @@
     EARL_GREY_TEST_SKIPPED(@"Skipped for iPad (no hidden toolbar in tablet)");
   }
 
-  web::test::SetUpFileBasedHttpServer();
   GURL URL = web::test::HttpServer::MakeUrl(
       "http://ios/testing/data/http_server_files/multi_field_form.html");
   [ChromeEarlGrey loadURL:URL];

diff --git a/ios/chrome/browser/device_sharing/handoff_manager_egtest.mm b/ios/chrome/browser/device_sharing/handoff_manager_egtest.mm
index dfbf467e..fa4bac3 100644
--- a/ios/chrome/browser/device_sharing/handoff_manager_egtest.mm
+++ b/ios/chrome/browser/device_sharing/handoff_manager_egtest.mm

@@ -47,13 +47,6 @@
 
 @implementation HandoffManagerTestCase
 
-#pragma mark - Overrides base class
-
-- (void)setUp {
-  [super setUp];
-  web::test::SetUpFileBasedHttpServer();
-}
-
 #pragma mark - Tests
 
 // Tests that an empty new tab page should result in no Handoff URL.

diff --git a/ios/chrome/browser/infobars/overlays/browser_agent/interaction_handlers/save_card/save_card_infobar_banner_interaction_handler.h b/ios/chrome/browser/infobars/overlays/browser_agent/interaction_handlers/save_card/save_card_infobar_banner_interaction_handler.h
index 6d07b92..4263326c 100644
--- a/ios/chrome/browser/infobars/overlays/browser_agent/interaction_handlers/save_card/save_card_infobar_banner_interaction_handler.h
+++ b/ios/chrome/browser/infobars/overlays/browser_agent/interaction_handlers/save_card/save_card_infobar_banner_interaction_handler.h

@@ -31,6 +31,10 @@
                                base::string16 expiration_date_month,
                                base::string16 expiration_date_year);
 
+  // Overrides InfobarBannerInteractionHandler implementation because a banner
+  // dismissal should not call InfoBarDismissed();
+  void BannerDismissedByUser(InfoBarIOS* infobar) override {}
+
  private:
   // InfobarBannerInteractionHandler:
   std::unique_ptr<InfobarBannerOverlayRequestCallbackInstaller>

diff --git a/ios/chrome/browser/infobars/overlays/browser_agent/interaction_handlers/save_card/save_card_infobar_banner_interaction_handler_unittest.mm b/ios/chrome/browser/infobars/overlays/browser_agent/interaction_handlers/save_card/save_card_infobar_banner_interaction_handler_unittest.mm
index 4d58002..0544380 100644
--- a/ios/chrome/browser/infobars/overlays/browser_agent/interaction_handlers/save_card/save_card_infobar_banner_interaction_handler_unittest.mm
+++ b/ios/chrome/browser/infobars/overlays/browser_agent/interaction_handlers/save_card/save_card_infobar_banner_interaction_handler_unittest.mm

@@ -60,3 +60,11 @@
   handler_.SaveCredentials(infobar_.get(), cardholder_name,
                            expiration_date_month, expiration_date_year);
 }
+
+// Test that dismissing the banner does not call
+// InfobarDelegate::InfobarDismissed(), which is a behavior for the other
+// Infobars.
+TEST_F(SaveCardInfobarBannerInteractionHandlerTest, DismissalNoDelegateCall) {
+  EXPECT_CALL(mock_delegate(), InfoBarDismissed()).Times(0);
+  handler_.BannerDismissedByUser(infobar_.get());
+}

diff --git a/ios/chrome/browser/infobars/overlays/browser_agent/interaction_handlers/test/mock_autofill_save_card_infobar_delegate_mobile.h b/ios/chrome/browser/infobars/overlays/browser_agent/interaction_handlers/test/mock_autofill_save_card_infobar_delegate_mobile.h
index 97b60dd..85e6783e 100644
--- a/ios/chrome/browser/infobars/overlays/browser_agent/interaction_handlers/test/mock_autofill_save_card_infobar_delegate_mobile.h
+++ b/ios/chrome/browser/infobars/overlays/browser_agent/interaction_handlers/test/mock_autofill_save_card_infobar_delegate_mobile.h

@@ -39,6 +39,7 @@
                     base::string16 expiration_date_month,
                     base::string16 expiration_date_year));
   MOCK_METHOD1(OnLegalMessageLinkClicked, void(GURL url));
+  MOCK_METHOD0(InfoBarDismissed, void());
 };
 
 class MockAutofillSaveCardInfoBarDelegateMobileFactory {

diff --git a/ios/chrome/browser/metrics/tab_usage_recorder_egtest.mm b/ios/chrome/browser/metrics/tab_usage_recorder_egtest.mm
index f663b078..b2e0c34 100644
--- a/ios/chrome/browser/metrics/tab_usage_recorder_egtest.mm
+++ b/ios/chrome/browser/metrics/tab_usage_recorder_egtest.mm

@@ -160,7 +160,6 @@
 // Tests that the recorder actual recorde tab state.
 // TODO(crbug.com/934228) The test is flaky.
 - (void)DISABLED_testTabSwitchRecorder {
-  web::test::SetUpFileBasedHttpServer();
   [ChromeEarlGrey resetTabUsageRecorder];
 
   // Open two tabs with urls.
@@ -217,7 +216,6 @@
 // Verifies the UMA metric for page loads before a tab eviction by loading
 // some tabs, forcing a tab eviction, then checking the histogram.
 - (void)testPageLoadCountBeforeEvictedTab {
-  web::test::SetUpFileBasedHttpServer();
   [ChromeEarlGrey resetTabUsageRecorder];
   const GURL url1 = web::test::HttpServer::MakeUrl(kTestUrl1);
   // This test opens three tabs.
@@ -291,7 +289,6 @@
 // EVICTED_DUE_TO_COLD_START.
 // TODO(crbug.com/934228) The test is disabled due to flakiness.
 - (void)DISABLED_testColdLaunchReloadCount {
-  web::test::SetUpFileBasedHttpServer();
   [ChromeEarlGrey resetTabUsageRecorder];
 
   // Open two tabs with urls.
@@ -362,7 +359,6 @@
 // Tests that tabs reloads after backgrounding and eviction.
 // TODO(crbug.com/934228) The test is flaky.
 - (void)DISABLED_testBackgroundingReloadCount {
-  web::test::SetUpFileBasedHttpServer();
   [ChromeEarlGrey resetTabUsageRecorder];
 
   // Open two tabs with urls.
@@ -427,8 +423,6 @@
 // succeeds.
 // TODO(crbug.com/934228) The test is flaky.
 - (void)DISABLED_testEvictedTabReloadSuccess {
-  web::test::SetUpFileBasedHttpServer();
-
   [ChromeEarlGrey closeAllTabsInCurrentMode];
   GURL URL = web::test::HttpServer::MakeUrl(kTestUrl1);
   NewMainTabWithURL(URL, kURL1FirstWord);
@@ -726,7 +720,6 @@
       "http://ios/testing/data/http_server_files/redirect_refresh.html");
   GURL destinationURL = web::test::HttpServer::MakeUrl(
       "http://ios/testing/data/http_server_files/destination.html");
-  web::test::SetUpFileBasedHttpServer();
   [ChromeEarlGrey resetTabUsageRecorder];
 
   NewMainTabWithURL(redirectURL, "arrived");
@@ -877,7 +870,6 @@
 
 // Tests that opening tabs from external app will not cause tab eviction.
 - (void)testOpenFromApp {
-  web::test::SetUpFileBasedHttpServer();
   [ChromeEarlGrey resetTabUsageRecorder];
 
   [ChromeEarlGrey openNewTab];
@@ -906,7 +898,6 @@
 // Verify that evicted tabs that are deleted are removed from the evicted tabs
 // map.
 - (void)testTabDeletion {
-  web::test::SetUpFileBasedHttpServer();
   [ChromeEarlGrey resetTabUsageRecorder];
   // Add an autorelease pool to delete the closed tabs before the end of the
   // test.

diff --git a/ios/chrome/browser/snapshots/snapshot_tab_helper.h b/ios/chrome/browser/snapshots/snapshot_tab_helper.h
index 0639b792..0fda90f 100644
--- a/ios/chrome/browser/snapshots/snapshot_tab_helper.h
+++ b/ios/chrome/browser/snapshots/snapshot_tab_helper.h

@@ -61,12 +61,6 @@
   // if snapshot generation fails.
   void UpdateSnapshotWithCallback(void (^callback)(UIImage*));
 
-  // DEPRECATED(crbug.com/917929): Use the asynchronous function
-  // |UpdateSnapshotWithCallback()| for all new callsites.
-  // Generates a new snapshot, updates the snapshot cache, and returns the new
-  // snapshot image. Returns nil if snapshot generation fails.
-  UIImage* UpdateSnapshot();
-
   // Generates a new snapshot without any overlays, and returns the new snapshot
   // image. This does not update the snapshot cache. Returns nil if snapshot
   // generation fails.

diff --git a/ios/chrome/browser/snapshots/snapshot_tab_helper.mm b/ios/chrome/browser/snapshots/snapshot_tab_helper.mm
index 38d93f80..5014db5 100644
--- a/ios/chrome/browser/snapshots/snapshot_tab_helper.mm
+++ b/ios/chrome/browser/snapshots/snapshot_tab_helper.mm

@@ -86,17 +86,13 @@
   }
   // Use the UIKit-based snapshot API as a fallback when the WKWebView API is
   // unavailable.
-  UIImage* image = UpdateSnapshot();
+  UIImage* image = [snapshot_generator_ updateSnapshot];
   dispatch_async(dispatch_get_main_queue(), ^{
     if (callback)
       callback(image);
   });
 }
 
-UIImage* SnapshotTabHelper::UpdateSnapshot() {
-  return [snapshot_generator_ updateSnapshot];
-}
-
 UIImage* SnapshotTabHelper::GenerateSnapshotWithoutOverlays() {
   return [snapshot_generator_ generateSnapshotWithOverlays:NO];
 }

diff --git a/ios/chrome/browser/snapshots/snapshot_tab_helper_unittest.mm b/ios/chrome/browser/snapshots/snapshot_tab_helper_unittest.mm
index 0f8dc2c..10bca57e 100644
--- a/ios/chrome/browser/snapshots/snapshot_tab_helper_unittest.mm
+++ b/ios/chrome/browser/snapshots/snapshot_tab_helper_unittest.mm

@@ -290,14 +290,24 @@
   EXPECT_EQ(delegate_.snapshotTakenCount, 1u);
 }
 
-// Tests that UpdateSnapshot ignores any cached snapshots, generate a new one
-// and updates the cache.
-TEST_F(SnapshotTabHelperTest, UpdateSnapshot) {
+// Tests that UpdateSnapshotWithCallback ignores any cached snapshots, generate
+// a new one and updates the cache.
+TEST_F(SnapshotTabHelperTest, UpdateSnapshotWithCallback) {
   SetCachedSnapshot(
       UIImageWithSizeAndSolidColor(kDefaultSnapshotSize, [UIColor greenColor]));
+  UIImage* original_cached_snapshot = GetCachedSnapshot();
 
-  UIImage* snapshot =
-      SnapshotTabHelper::FromWebState(&web_state_)->UpdateSnapshot();
+  base::RunLoop run_loop;
+  base::RunLoop* run_loop_ptr = &run_loop;
+
+  __block UIImage* snapshot = nil;
+  SnapshotTabHelper::FromWebState(&web_state_)
+      ->UpdateSnapshotWithCallback(^(UIImage* image) {
+        snapshot = image;
+        run_loop_ptr->Quit();
+      });
+
+  run_loop.Run();
 
   ASSERT_TRUE(snapshot);
   EXPECT_TRUE(CGSizeEqualToSize(snapshot.size, kWebStateViewSize));
@@ -305,6 +315,7 @@
 
   UIImage* cached_snapshot = GetCachedSnapshot();
   EXPECT_TRUE(UIImagesAreEqual(snapshot, cached_snapshot));
+  EXPECT_FALSE(UIImagesAreEqual(snapshot, original_cached_snapshot));
   EXPECT_EQ(delegate_.snapshotTakenCount, 1u);
 }
 

diff --git a/ios/chrome/browser/ui/fullscreen/fullscreen_egtest.mm b/ios/chrome/browser/ui/fullscreen/fullscreen_egtest.mm
index 8807533..00f42bb 100644
--- a/ios/chrome/browser/ui/fullscreen/fullscreen_egtest.mm
+++ b/ios/chrome/browser/ui/fullscreen/fullscreen_egtest.mm

@@ -97,7 +97,6 @@
 // TODO(crbug.com/947536): Fails on iOS 12 devices.
 // TODO(crbug.com/1106997): Test fails in simulator builders.
 - (void)DISABLED_testLongPDFInitialState {
-  web::test::SetUpFileBasedHttpServer();
   GURL URL = web::test::HttpServer::MakeUrl(
       "http://ios/testing/data/http_server_files/two_pages.pdf");
   [ChromeEarlGrey loadURL:URL];
@@ -127,7 +126,6 @@
   }
 #endif
 
-  web::test::SetUpFileBasedHttpServer();
   GURL URL = web::test::HttpServer::MakeUrl(
       "http://ios/testing/data/http_server_files/single_page_wide.pdf");
   [ChromeEarlGrey loadURL:URL];
@@ -161,7 +159,6 @@
 #define MAYBE_testLongPDFScroll testLongPDFScroll
 #endif
 - (void)MAYBE_testLongPDFScroll {
-  web::test::SetUpFileBasedHttpServer();
   GURL URL = web::test::HttpServer::MakeUrl(
       "http://ios/testing/data/http_server_files/two_pages.pdf");
   [ChromeEarlGrey loadURL:URL];

diff --git a/ios/chrome/browser/ui/popup_menu/popup_menu_egtest.mm b/ios/chrome/browser/ui/popup_menu/popup_menu_egtest.mm
index 3c24def..9222032 100644
--- a/ios/chrome/browser/ui/popup_menu/popup_menu_egtest.mm
+++ b/ios/chrome/browser/ui/popup_menu/popup_menu_egtest.mm

@@ -165,7 +165,6 @@
     EARL_GREY_TEST_DISABLED(@"EG1 flaky on iOS 12.");
   }
 #endif
-  web::test::SetUpFileBasedHttpServer();
   const GURL URL = web::test::HttpServer::MakeUrl(kPDFURL);
 
   // Navigate to a mock pdf and verify that the find button is disabled.

diff --git a/ios/chrome/browser/ui/popup_menu/request_desktop_mobile_site_egtest.mm b/ios/chrome/browser/ui/popup_menu/request_desktop_mobile_site_egtest.mm
index 3a1c3561..3395664 100644
--- a/ios/chrome/browser/ui/popup_menu/request_desktop_mobile_site_egtest.mm
+++ b/ios/chrome/browser/ui/popup_menu/request_desktop_mobile_site_egtest.mm

@@ -415,7 +415,6 @@
 //
 // Disabled due to flakiness: https://crbug.com/1111194.
 - (void)DISABLED_testAppVersionJSAPIWithMobileUserAgent {
-  web::test::SetUpFileBasedHttpServer();
   [ChromeEarlGrey loadURL:web::test::HttpServer::MakeUrl(kUserAgentTestURL)];
   // Verify initial reception of the mobile site.
   [ChromeEarlGrey waitForWebStateContainingText:[self defaultLabel]];

diff --git a/ios/chrome/browser/ui/sad_tab/sad_tab_view_egtest.mm b/ios/chrome/browser/ui/sad_tab/sad_tab_view_egtest.mm
index 48fbd204..7ba22bb 100644
--- a/ios/chrome/browser/ui/sad_tab/sad_tab_view_egtest.mm
+++ b/ios/chrome/browser/ui/sad_tab/sad_tab_view_egtest.mm

@@ -70,7 +70,6 @@
     EARL_GREY_TEST_DISABLED(@"Fails on iOS 13.");
   }
   // Prepare a simple but known URL to avoid testing from the NTP.
-  web::test::SetUpFileBasedHttpServer();
   const GURL simple_URL = web::test::HttpServer::MakeUrl(
       "http://ios/testing/data/http_server_files/destination.html");
 

diff --git a/ios/chrome/browser/ui/toolbar/toolbar_egtest.mm b/ios/chrome/browser/ui/toolbar/toolbar_egtest.mm
index 1539d63..af82e39 100644
--- a/ios/chrome/browser/ui/toolbar/toolbar_egtest.mm
+++ b/ios/chrome/browser/ui/toolbar/toolbar_egtest.mm

@@ -36,7 +36,6 @@
 // Verifies that entering a URL in the omnibox navigates to the correct URL and
 // displays content.
 - (void)testEnterURL {
-  web::test::SetUpFileBasedHttpServer();
   const GURL URL = web::test::HttpServer::MakeUrl(
       "http://ios/testing/data/http_server_files/destination.html");
   [ChromeEarlGrey loadURL:URL];

diff --git a/ios/chrome/browser/web/browsing_egtest.mm b/ios/chrome/browser/web/browsing_egtest.mm
index 1902593..b0a88155 100644
--- a/ios/chrome/browser/web/browsing_egtest.mm
+++ b/ios/chrome/browser/web/browsing_egtest.mm

@@ -110,8 +110,6 @@
     EARL_GREY_TEST_SKIPPED(@"Tab Title not displayed on handset.");
   }
 
-  web::test::SetUpFileBasedHttpServer();
-
   const GURL destinationURL = web::test::HttpServer::MakeUrl(
       "http://ios/testing/data/http_server_files/destination.html");
   [ChromeEarlGrey loadURL:destinationURL];
@@ -130,8 +128,6 @@
     EARL_GREY_TEST_SKIPPED(@"Tab Title not displayed on handset.");
   }
 
-  web::test::SetUpFileBasedHttpServer();
-
   const GURL destinationURL = web::test::HttpServer::MakeUrl(
       "http://ios/testing/data/http_server_files/testpage.pdf");
   [ChromeEarlGrey loadURL:destinationURL];

diff --git a/ios/chrome/browser/web/browsing_prevent_default_egtest.mm b/ios/chrome/browser/web/browsing_prevent_default_egtest.mm
index 77eda2e..398f371 100644
--- a/ios/chrome/browser/web/browsing_prevent_default_egtest.mm
+++ b/ios/chrome/browser/web/browsing_prevent_default_egtest.mm

@@ -42,7 +42,6 @@
   // Disable popup blocking, because that will mask failures that try to open
   // new tabs.
   ScopedBlockPopupsPref scoper(CONTENT_SETTING_ALLOW);
-  web::test::SetUpFileBasedHttpServer();
 
   const GURL testURL = GetTestUrl();
   [ChromeEarlGrey loadURL:testURL];
@@ -81,7 +80,6 @@
   // Disable popup blocking, because that will mask failures that try to open
   // new tabs.
   ScopedBlockPopupsPref scoper(CONTENT_SETTING_ALLOW);
-  web::test::SetUpFileBasedHttpServer();
 
   const GURL testURL = GetTestUrl();
   [ChromeEarlGrey loadURL:testURL];

diff --git a/ios/chrome/browser/web/child_window_open_by_dom_egtest.mm b/ios/chrome/browser/web/child_window_open_by_dom_egtest.mm
index 82b386d..5dd23051 100644
--- a/ios/chrome/browser/web/child_window_open_by_dom_egtest.mm
+++ b/ios/chrome/browser/web/child_window_open_by_dom_egtest.mm

@@ -86,7 +86,6 @@
 
 + (void)setUpHelper {
   [ChromeEarlGrey setContentSettings:CONTENT_SETTING_ALLOW];
-  web::test::SetUpFileBasedHttpServer();
 }
 
 + (void)tearDown {

diff --git a/ios/chrome/browser/web/push_and_replace_state_navigation_egtest.mm b/ios/chrome/browser/web/push_and_replace_state_navigation_egtest.mm
index 9f7c87c..91746cf 100644
--- a/ios/chrome/browser/web/push_and_replace_state_navigation_egtest.mm
+++ b/ios/chrome/browser/web/push_and_replace_state_navigation_egtest.mm

@@ -58,7 +58,6 @@
       web::test::HttpServer::MakeUrl("http://ios/pa%20th");
   const std::string pushStatePathSpaceOmniboxText =
       net::GetContentAndFragmentForUrl(pushStatePathSpaceURL);
-  web::test::SetUpFileBasedHttpServer();
   [ChromeEarlGrey loadURL:web::test::HttpServer::MakeUrl(kHistoryTestUrl)];
 
   // Push 3 URLs. Verify that the URL changed and the status was updated.
@@ -98,7 +97,6 @@
 
 // Tests that calling replaceState() changes the current history entry.
 - (void)testHtml5HistoryReplaceStateThenGoBackAndForward {
-  web::test::SetUpFileBasedHttpServer();
   const GURL initialURL = web::test::HttpServer::MakeUrl(kNonPushedUrl);
   const std::string initialOmniboxText =
       net::GetContentAndFragmentForUrl(initialURL);
@@ -187,7 +185,6 @@
   const std::string replaceStateThenPushStateOmniboxText =
       net::GetContentAndFragmentForUrl(replaceStateThenPushStateURL);
 
-  web::test::SetUpFileBasedHttpServer();
   [ChromeEarlGrey loadURL:web::test::HttpServer::MakeUrl(kHistoryTestUrl)];
 
   // Replace state and then push state. Verify that at the end, the URL changed
@@ -221,8 +218,6 @@
   const std::string pushStateThenReplaceStateOmniboxText =
       net::GetContentAndFragmentForUrl(pushStateThenReplaceStateURL);
 
-  web::test::SetUpFileBasedHttpServer();
-
   const GURL historyTestURL = web::test::HttpServer::MakeUrl(kHistoryTestUrl);
   [ChromeEarlGrey loadURL:historyTestURL];
   const std::string historyTestOmniboxText =
@@ -248,7 +243,6 @@
 // Tests that page loads occur when navigating to or past a non-pushed URL.
 - (void)testHtml5HistoryNavigatingPastNonPushedURL {
   GURL nonPushedURL = web::test::HttpServer::MakeUrl(kNonPushedUrl);
-  web::test::SetUpFileBasedHttpServer();
   const GURL historyTestURL = web::test::HttpServer::MakeUrl(kHistoryTestUrl);
   [ChromeEarlGrey loadURL:historyTestURL];
   const std::string historyTestOmniboxText =
@@ -324,7 +318,6 @@
   const char pushStateUnicode2Label[] = "Action: pushStateUnicode2∢";
   NSString* pushStateUnicode2Status = @"pushStateUnicode2∢";
 
-  web::test::SetUpFileBasedHttpServer();
   [ChromeEarlGrey loadURL:web::test::HttpServer::MakeUrl(kHistoryTestUrl)];
 
   // Do 2 push states with unicode characters.

diff --git a/ios/web/navigation/history_state_operations_inttest.mm b/ios/web/navigation/history_state_operations_inttest.mm
index 5e714ff..382bed5 100644
--- a/ios/web/navigation/history_state_operations_inttest.mm
+++ b/ios/web/navigation/history_state_operations_inttest.mm

@@ -66,9 +66,6 @@
   void SetUp() override {
     web::WebIntTest::SetUp();
 
-    // History state tests use file-based test pages.
-    web::test::SetUpFileBasedHttpServer();
-
     // Load the history state test page.
     state_operations_url_ =
         web::test::HttpServer::MakeUrl(kHistoryStateOperationsTestUrl);

diff --git a/ios/web/navigation/window_location_inttest.mm b/ios/web/navigation/window_location_inttest.mm
index 139d61c..4865713 100644
--- a/ios/web/navigation/window_location_inttest.mm
+++ b/ios/web/navigation/window_location_inttest.mm

@@ -62,9 +62,6 @@
   void SetUp() override {
     web::WebIntTest::SetUp();
 
-    // window.location tests use file-based test pages.
-    web::test::SetUpFileBasedHttpServer();
-
     // Load the window.location test page.
     window_location_url_ =
         web::test::HttpServer::MakeUrl(kWindowLocationTestURL);

diff --git a/ios/web/public/test/http_server/http_server_util.h b/ios/web/public/test/http_server/http_server_util.h
index 49cdc230..9f8a4b3 100644
--- a/ios/web/public/test/http_server/http_server_util.h
+++ b/ios/web/public/test/http_server/http_server_util.h

@@ -19,20 +19,6 @@
 // HtmlResponseProvider will use the |responses| map to resolve URLs.
 void SetUpSimpleHttpServer(const std::map<GURL, std::string>& responses);
 
-// Sets up a web::test::HttpServer with a simple HtmlResponseProvider. The
-// HtmlResponseProvider will use the |responses| map to resolve URLs. The value
-// of |responses| is the cookie and response body pair where the first string is
-// the cookie and the second string is the response body. Set the cookie string
-// as empty string if cookie is not needed in the response headers.
-void SetUpSimpleHttpServerWithSetCookies(
-    const std::map<GURL, std::pair<std::string, std::string>>& responses);
-
-// Sets up a web::test::HttpServer with a FileBasedResponseProvider. The
-// server will try to resolve URLs as file paths relative to the application
-// bundle path. web::test::MakeUrl should be used to rewrite URLs before doing
-// a request.
-void SetUpFileBasedHttpServer();
-
 // Sets up a web::test::HttpServer with a single custom provider.
 // Takes ownership of the provider.
 void SetUpHttpServer(std::unique_ptr<web::ResponseProvider> provider);

diff --git a/ios/web/public/test/http_server/http_server_util.mm b/ios/web/public/test/http_server/http_server_util.mm
index e0d9a58..73c8bd6 100644
--- a/ios/web/public/test/http_server/http_server_util.mm
+++ b/ios/web/public/test/http_server/http_server_util.mm

@@ -21,15 +21,6 @@
   SetUpHttpServer(std::make_unique<HtmlResponseProvider>(responses));
 }
 
-void SetUpSimpleHttpServerWithSetCookies(
-    const std::map<GURL, std::pair<std::string, std::string>>& responses) {
-  SetUpHttpServer(std::make_unique<HtmlResponseProvider>(responses));
-}
-
-// TODO(crbug.com/694859): Cleanup tests and remove the function. Not
-// necessary after switching to EmbeddedTestServer.
-void SetUpFileBasedHttpServer() {}
-
 void SetUpHttpServer(std::unique_ptr<web::ResponseProvider> provider) {
   web::test::HttpServer& server = web::test::HttpServer::GetSharedInstance();
   DCHECK(server.IsRunning());

diff --git a/media/base/media_switches.cc b/media/base/media_switches.cc
index 107dfd2..67e5c958 100644
--- a/media/base/media_switches.cc
+++ b/media/base/media_switches.cc

@@ -370,6 +370,10 @@
 const base::Feature kGlobalMediaControlsForCast{
     "GlobalMediaControlsForCast", base::FEATURE_DISABLED_BY_DEFAULT};
 
+// Allow Global Media Controls in system tray of CrOS.
+const base::Feature kGlobalMediaControlsForChromeOS{
+    "GlobalMediaControlsForChromeOS", base::FEATURE_DISABLED_BY_DEFAULT};
+
 // Allow global media controls notifications to be dragged out into overlay
 // notifications. It is no-op if kGlobalMediaControls is not enabled.
 const base::Feature kGlobalMediaControlsOverlayControls{

diff --git a/media/base/media_switches.h b/media/base/media_switches.h
index e863d1a9..602a312 100644
--- a/media/base/media_switches.h
+++ b/media/base/media_switches.h

@@ -126,6 +126,7 @@
 MEDIA_EXPORT extern const base::Feature kGlobalMediaControls;
 MEDIA_EXPORT extern const base::Feature kGlobalMediaControlsAutoDismiss;
 MEDIA_EXPORT extern const base::Feature kGlobalMediaControlsForCast;
+MEDIA_EXPORT extern const base::Feature kGlobalMediaControlsForChromeOS;
 MEDIA_EXPORT extern const base::Feature kGlobalMediaControlsOverlayControls;
 MEDIA_EXPORT extern const base::Feature kGlobalMediaControlsPictureInPicture;
 MEDIA_EXPORT extern const base::Feature kGlobalMediaControlsSeamlessTransfer;

diff --git a/media/gpu/test/video_frame_validator.cc b/media/gpu/test/video_frame_validator.cc
index fad3db30..65b64b30 100644
--- a/media/gpu/test/video_frame_validator.cc
+++ b/media/gpu/test/video_frame_validator.cc

@@ -5,13 +5,18 @@
 #include "media/gpu/test/video_frame_validator.h"
 
 #include "base/bind.h"
+#include "base/cpu.h"
 #include "base/files/file.h"
 #include "base/hash/md5.h"
 #include "base/memory/ptr_util.h"
+#include "base/no_destructor.h"
 #include "base/numerics/safe_conversions.h"
+#include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
+#include "base/system/sys_info.h"
 #include "build/build_config.h"
 #include "media/base/video_frame.h"
+#include "media/gpu/buildflags.h"
 #include "media/gpu/macros.h"
 #include "media/gpu/test/image_quality_metrics.h"
 #include "media/gpu/test/video_test_helpers.h"
@@ -231,6 +236,27 @@
 MD5VideoFrameValidator::Validate(scoped_refptr<const VideoFrame> frame,
                                  size_t frame_index) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(validator_thread_sequence_checker_);
+#if BUILDFLAG(USE_VAAPI)
+  // b/149808895: There is a bug in the synchronization on mapped buffers, which
+  // causes the frame validation failure. The bug is due to some missing i915
+  // patches in kernel v3.18. The bug will be fixed if the kernel is upreved to
+  // v4.4 or newer. Inserts usleep as a short term workaround to the
+  // synchronization bug until the kernel uprev is complete for all the v3.18
+  // devices. Since this bug only occurs in Skylake just because they are 3.18
+  // devices, we also filter by the processor.
+  const static std::string kernel_version = base::SysInfo::KernelVersion();
+  if (base::StartsWith(kernel_version, "3.18")) {
+    constexpr int kPentiumAndLaterFamily = 0x06;
+    constexpr int kSkyLakeModelId = 0x5E;
+    constexpr int kSkyLake_LModelId = 0x4E;
+    static base::NoDestructor<base::CPU> cpuid;
+    static bool is_skylake = cpuid->family() == kPentiumAndLaterFamily &&
+                             (cpuid->model() == kSkyLakeModelId ||
+                              cpuid->model() == kSkyLake_LModelId);
+    if (is_skylake)
+      usleep(10);
+  }
+#endif  // BUILDFLAG(USE_VAAPI)
   if (frame->format() != validation_format_) {
     frame = ConvertVideoFrame(frame.get(), validation_format_);
   }

diff --git a/printing/printing_features.cc b/printing/printing_features.cc
index ad7b5b4..058e60b 100644
--- a/printing/printing_features.cc
+++ b/printing/printing_features.cc

@@ -18,9 +18,6 @@
 // calls the deprecated PPD API.
 const base::Feature kCupsIppPrintingBackend{"CupsIppPrintingBackend",
                                             base::FEATURE_DISABLED_BY_DEFAULT};
-
-const base::Feature kEnableCustomMacPaperSizes{
-    "EnableCustomMacPaperSizes", base::FEATURE_ENABLED_BY_DEFAULT};
 #endif  // defined(OS_MAC)
 
 #if defined(OS_WIN)

diff --git a/printing/printing_features.h b/printing/printing_features.h
index bd9e387..3c6e97b 100644
--- a/printing/printing_features.h
+++ b/printing/printing_features.h

@@ -21,7 +21,6 @@
 
 #if defined(OS_MAC)
 PRINTING_EXPORT extern const base::Feature kCupsIppPrintingBackend;
-PRINTING_EXPORT extern const base::Feature kEnableCustomMacPaperSizes;
 #endif  // defined(OS_MAC)
 
 #if defined(OS_WIN)

diff --git a/services/device/usb/usb_context_unittest.cc b/services/device/usb/usb_context_unittest.cc
index a82944c..6f1faee 100644
--- a/services/device/usb/usb_context_unittest.cc
+++ b/services/device/usb/usb_context_unittest.cc

@@ -28,7 +28,7 @@
 
 }  // namespace
 
-#if defined(OS_LINUX)
+#if defined(OS_LINUX) || defined(OS_CHROMEOS)
 // Linux trybot does not support usb.
 #define MAYBE_GracefulShutdown DISABLED_GracefulShutdown
 #elif defined(OS_ANDROID)

diff --git a/services/network/url_loader_unittest.cc b/services/network/url_loader_unittest.cc
index 72b1801..9660215 100644
--- a/services/network/url_loader_unittest.cc
+++ b/services/network/url_loader_unittest.cc

@@ -482,8 +482,8 @@
       kBodyReadFromNetBeforePausedHistogram,
       base::BindRepeating(
           [](const base::RepeatingClosure& quit_closure,
-             base::HistogramBase::Sample* output,
-             base::HistogramBase::Sample sample) {
+             base::HistogramBase::Sample* output, const char* histogram_name,
+             uint64_t name_hash, base::HistogramBase::Sample sample) {
             *output = sample;
             quit_closure.Run();
           },

diff --git a/services/tracing/public/cpp/background_tracing/background_tracing_agent_impl.cc b/services/tracing/public/cpp/background_tracing/background_tracing_agent_impl.cc
index 99d3f93..c5612437d 100644
--- a/services/tracing/public/cpp/background_tracing/background_tracing_agent_impl.cc
+++ b/services/tracing/public/cpp/background_tracing/background_tracing_agent_impl.cc

@@ -46,8 +46,8 @@
       histogram_name,
       base::BindRepeating(&BackgroundTracingAgentImpl::OnHistogramChanged,
                           weak_self, base::SequencedTaskRunnerHandle::Get(),
-                          histogram_name, histogram_lower_value,
-                          histogram_upper_value, repeat));
+                          histogram_lower_value, histogram_upper_value,
+                          repeat));
 
   base::HistogramBase* existing_histogram =
       base::StatisticsRecorder::FindHistogram(histogram_name);
@@ -93,10 +93,11 @@
 void BackgroundTracingAgentImpl::OnHistogramChanged(
     base::WeakPtr<BackgroundTracingAgentImpl> weak_self,
     scoped_refptr<base::SequencedTaskRunner> task_runner,
-    const std::string& histogram_name,
     base::Histogram::Sample histogram_lower_value,
     base::Histogram::Sample histogram_upper_value,
     bool repeat,
+    const char* histogram_name,
+    uint64_t name_hash,
     base::Histogram::Sample actual_value) {
   // NOTE: This method is called from an arbitrary sequence.
 
@@ -115,7 +116,7 @@
               [&](perfetto::EventContext ctx) {
                 perfetto::protos::pbzero::ChromeHistogramSample* new_sample =
                     ctx.event()->set_chrome_histogram_sample();
-                new_sample->set_name_hash(base::HashMetricName(histogram_name));
+                new_sample->set_name_hash(name_hash);
                 new_sample->set_sample(actual_value);
               });
 

diff --git a/services/tracing/public/cpp/background_tracing/background_tracing_agent_impl.h b/services/tracing/public/cpp/background_tracing/background_tracing_agent_impl.h
index eeab3b27..7406604 100644
--- a/services/tracing/public/cpp/background_tracing/background_tracing_agent_impl.h
+++ b/services/tracing/public/cpp/background_tracing/background_tracing_agent_impl.h

@@ -40,10 +40,11 @@
   static void OnHistogramChanged(
       base::WeakPtr<BackgroundTracingAgentImpl> weak_self,
       scoped_refptr<base::SequencedTaskRunner> task_runner,
-      const std::string& histogram_name,
       base::Histogram::Sample reference_lower_value,
       base::Histogram::Sample reference_upper_value,
       bool repeat,
+      const char* histogram_name,
+      uint64_t name_hash,
       base::Histogram::Sample actual_value);
   void SendTriggerMessage(const std::string& histogram_name);
   void SendAbortBackgroundTracingMessage();

diff --git a/services/tracing/public/cpp/perfetto/trace_event_data_source.cc b/services/tracing/public/cpp/perfetto/trace_event_data_source.cc
index ea32fad..36270b5 100644
--- a/services/tracing/public/cpp/perfetto/trace_event_data_source.cc
+++ b/services/tracing/public/cpp/perfetto/trace_event_data_source.cc

@@ -470,10 +470,27 @@
       &TraceEventDataSource::FlushCurrentThread,
       &TraceEventDataSource::OnUpdateDuration);
 
+  DCHECK(monitored_histograms_.empty());
   if (trace_config.IsCategoryGroupEnabled(
           TRACE_DISABLED_BY_DEFAULT("histogram_samples"))) {
-    base::StatisticsRecorder::SetGlobalSampleCallback(
-        &TraceEventDataSource::OnMetricsSampleCallback);
+    if (trace_config.histogram_names().empty()) {
+      base::StatisticsRecorder::SetGlobalSampleCallback(
+          &TraceEventDataSource::OnMetricsSampleCallback);
+    } else {
+      for (const std::string& histogram_name : trace_config.histogram_names()) {
+        if (base::StatisticsRecorder::SetCallback(
+                histogram_name,
+                base::BindRepeating(
+                    &TraceEventDataSource::OnMetricsSampleCallback))) {
+          monitored_histograms_.emplace_back(histogram_name);
+        } else {
+          // TODO(crbug/1119851): Refactor SetCallback to allow multiple
+          // callbacks for a single histogram.
+          LOG(WARNING) << "OnMetricsSampleCallback was not set for histogram "
+                       << histogram_name;
+        }
+      }
+    }
   }
 
   base::AutoLock l(lock_);
@@ -855,6 +872,11 @@
   }
 
   base::StatisticsRecorder::SetGlobalSampleCallback(nullptr);
+  for (const std::string& histogram_name : monitored_histograms_) {
+    base::StatisticsRecorder::ClearCallback(histogram_name);
+  }
+  monitored_histograms_.clear();
+
   auto task_runner = base::GetRecordActionTaskRunner();
   if (task_runner) {
     task_runner->PostTask(

diff --git a/services/tracing/public/cpp/perfetto/trace_event_data_source.h b/services/tracing/public/cpp/perfetto/trace_event_data_source.h
index 9de35c76..b0613a0 100644
--- a/services/tracing/public/cpp/perfetto/trace_event_data_source.h
+++ b/services/tracing/public/cpp/perfetto/trace_event_data_source.h

@@ -180,8 +180,10 @@
 
   bool IsEnabled();
 
-  // Registered with base::StatisticsRecorder to receive a callback on every
-  // histogram sample which gets added.
+  // Records trace event for a histogram sample. When histogram_samples category
+  // is enabled, it is registered with base::StatisticsRecorder to monitor the
+  // histograms listed in the trace config. If there are no histograms listed in
+  // the trace config, all the histograms will be monitored.
   static void OnMetricsSampleCallback(const char* histogram_name,
                                       uint64_t name_hash,
                                       base::HistogramBase::Sample sample);
@@ -263,6 +265,10 @@
   bool flushing_trace_log_ = false;
   base::OnceClosure flush_complete_task_;
   std::vector<std::string> histograms_;
+  // Stores all histogram names for which OnMetricsSampleCallback was set as an
+  // OnSampleCallback. This is done in order to avoid clearing callbacks for the
+  // other histograms.
+  std::vector<std::string> monitored_histograms_;
   bool privacy_filtering_enabled_ = false;
   std::string process_name_;
   int process_id_ = base::kNullProcessId;

diff --git a/services/tracing/public/cpp/perfetto/trace_event_data_source_unittest.cc b/services/tracing/public/cpp/perfetto/trace_event_data_source_unittest.cc
index 83af5e52..fdd13c9 100644
--- a/services/tracing/public/cpp/perfetto/trace_event_data_source_unittest.cc
+++ b/services/tracing/public/cpp/perfetto/trace_event_data_source_unittest.cc

@@ -1898,7 +1898,7 @@
   EXPECT_FALSE(e_packet->track_event().has_log_message());
 }
 
-TEST_F(TraceEventDataSourceTest, HistogramSample) {
+TEST_F(TraceEventDataSourceTest, HistogramSampleTraceConfigEmpty) {
   base::trace_event::TraceConfig trace_config(
       "-*,disabled-by-default-histogram_samples",
       base::trace_event::RECORD_UNTIL_FULL);
@@ -1921,6 +1921,48 @@
   EXPECT_EQ(e_packet->track_event().chrome_histogram_sample().sample(), 1u);
 }
 
+TEST_F(TraceEventDataSourceTest, HistogramSampleTraceConfigNotEmpty) {
+  base::trace_event::TraceConfig trace_config(
+      "-*,disabled-by-default-histogram_samples",
+      base::trace_event::RECORD_UNTIL_FULL);
+  trace_config.EnableHistogram("Foo1.Bar1");
+  trace_config.EnableHistogram("Foo3.Bar3");
+
+  CreateTraceEventDataSource(/*privacy_filtering_enabled=*/false,
+                             /*start_trace=*/true, trace_config.ToString());
+
+  UMA_HISTOGRAM_BOOLEAN("Foo1.Bar1", true);
+  UMA_HISTOGRAM_BOOLEAN("Foo2.Bar2", true);
+  UMA_HISTOGRAM_BOOLEAN("Foo3.Bar3", true);
+
+  size_t packet_index = ExpectStandardPreamble();
+
+  auto* e_packet = producer_client()->GetFinalizedPacket(packet_index++);
+
+  ExpectEventCategories(e_packet,
+                        {{1u, TRACE_DISABLED_BY_DEFAULT("histogram_samples")}});
+  ExpectEventNames(e_packet, {{1u, "HistogramSample"}});
+  ASSERT_TRUE(e_packet->track_event().has_chrome_histogram_sample());
+  EXPECT_EQ(e_packet->track_event().chrome_histogram_sample().name_hash(),
+            base::HashMetricName("Foo1.Bar1"));
+  EXPECT_EQ(e_packet->track_event().chrome_histogram_sample().name(),
+            "Foo1.Bar1");
+  EXPECT_EQ(e_packet->track_event().chrome_histogram_sample().sample(), 1u);
+
+  e_packet = producer_client()->GetFinalizedPacket(packet_index++);
+
+  ExpectEventCategories(e_packet, {});
+  ExpectEventNames(e_packet, {});
+  ASSERT_TRUE(e_packet->track_event().has_chrome_histogram_sample());
+  EXPECT_EQ(e_packet->track_event().chrome_histogram_sample().name_hash(),
+            base::HashMetricName("Foo3.Bar3"));
+  EXPECT_EQ(e_packet->track_event().chrome_histogram_sample().name(),
+            "Foo3.Bar3");
+  EXPECT_EQ(e_packet->track_event().chrome_histogram_sample().sample(), 1u);
+
+  EXPECT_EQ(packet_index, producer_client()->GetFinalizedPacketCount());
+}
+
 TEST_F(TraceEventDataSourceTest, UserActionEvent) {
   base::SetRecordActionTaskRunner(base::ThreadTaskRunnerHandle::Get());
 

diff --git a/services/tracing/public/cpp/trace_startup.cc b/services/tracing/public/cpp/trace_startup.cc
index 7629795..ae1c5d7 100644
--- a/services/tracing/public/cpp/trace_startup.cc
+++ b/services/tracing/public/cpp/trace_startup.cc

@@ -153,21 +153,23 @@
 
   const auto trace_config = trace_log->GetCurrentTraceConfig();
 
-  // We can't currently propagate event filter options, memory dump configs, or
-  // trace buffer sizes via command line flags (they only support categories,
-  // trace options, record mode). If event filters are set, we bail out here to
-  // avoid recording events that we shouldn't in the child process. Even if
-  // memory dump config is set, it's OK to propagate the remaining config,
-  // because the child won't record events it shouldn't without it and will
-  // adopt the memory dump config once it connects to the tracing service.
-  // Buffer sizes configure the tracing service's central buffer, so also don't
-  // affect local tracing.
+  // We can't currently propagate event filter options, histogram names, memory
+  // dump configs, or trace buffer sizes via command line flags (they only
+  // support categories, trace options, record mode). If event filters or
+  // histogram names are set, we bail out here to avoid recording events that we
+  // shouldn't in the child process. Even if memory dump config is set, it's OK
+  // to propagate the remaining config, because the child won't record events it
+  // shouldn't without it and will adopt the memory dump config once it connects
+  // to the tracing service. Buffer sizes configure the tracing service's
+  // central buffer, so also don't affect local tracing.
   //
   // TODO(eseckler): Support propagating the full config via command line flags
   // somehow (--trace-config?). This will also need some rethinking to support
   // multiple concurrent tracing sessions in the future.
   if (!trace_config.event_filters().empty())
     return;
+  if (!trace_config.histogram_names().empty())
+    return;
 
   // Make sure that the startup session uses privacy filtering mode if it's
   // enabled for the browser's session.

diff --git a/testing/buildbot/OWNERS b/testing/buildbot/OWNERS
index 3e2a692..07fb5e1 100644
--- a/testing/buildbot/OWNERS
+++ b/testing/buildbot/OWNERS

@@ -22,5 +22,11 @@
 # For OOBE-related test filters.
 per-file *oobe*=file://chrome/browser/ui/webui/chromeos/login/OWNERS
 
+# Owners of variants.pyl will be added as post submit reviewers to CL's
+# generated by the infra recipe build_weblayer_version_tests_apk_cipd_pkg.
+# See crbug.com/1041619.
+per-file variants.pyl=rmhasan@google.com
+per-file variants.pyl=estaab@chromium.org
+
 # TEAM: infra-dev@chromium.org
 # COMPONENT: Infra>Client>Chrome

diff --git a/testing/buildbot/chromium.ci.json b/testing/buildbot/chromium.ci.json
index 52d36ec..b879531 100644
--- a/testing/buildbot/chromium.ci.json
+++ b/testing/buildbot/chromium.ci.json

@@ -75448,7 +75448,6 @@
           "can_use_on_swarming_builders": true,
           "dimension_sets": [
             {
-              "gpu": "8086:0a2e",
               "os": "Mac-10.13.6"
             }
           ],

diff --git a/testing/buildbot/chromium.mac.json b/testing/buildbot/chromium.mac.json
index 70f38cd..555036ab 100644
--- a/testing/buildbot/chromium.mac.json
+++ b/testing/buildbot/chromium.mac.json

@@ -6483,7 +6483,6 @@
           "can_use_on_swarming_builders": true,
           "dimension_sets": [
             {
-              "gpu": "8086:0a2e",
               "os": "Mac-10.13.6"
             }
           ],

diff --git a/testing/buildbot/filters/lacros.browser_tests.filter b/testing/buildbot/filters/lacros.browser_tests.filter
index a552cac9..e95bb19 100644
--- a/testing/buildbot/filters/lacros.browser_tests.filter
+++ b/testing/buildbot/filters/lacros.browser_tests.filter

@@ -36,6 +36,7 @@
 -AutofillProviderBrowserTest.FrameDetachedOnFormlessSubmission

 -AutofillProviderBrowserTestWithSkipFlagOn.InferredLabelChangeNotImpactFormComparing

 -AutomationApiTest.ForceLayout

+-AutomationManagerAuraBrowserTest.EventFromAction

 -AutoplayExtensionBrowserTest.AutoplayAllowedInIframe

 -BluetoothApiTest.*

 -BluetoothLowEnergyApiTest.*

@@ -214,3 +215,13 @@
 -WebViewTest.Shim_TestDisplayNoneWebviewRemoveChild

 -WelcomeA11y.WelcomeFlow_listitem

 -WorkerTaskProviderBrowserTest.CreateTasksForMultiProfiles

+

+# crbug.com/1121486

+# Following tests were flaky. We disable them first until we have time to investigate.

+-DevToolsExtensionTest.HttpIframeInDevToolsExtensionDevtools

+-DevToolsSanityTest.*

+-FindInPageControllerTest.SingleOccurrence

+-MediaRouterUIBrowserTest.PinAndUnpinToolbarIcon

+-MultiActionAPITest.PopupCreation/*

+-PDFExtensionClipboardTest.CombinedShiftArrowPresses

+-PopupTrackerBrowserTest.ControlClick_HasTracker


diff --git a/testing/buildbot/filters/lacros.interactive_ui_tests.filter b/testing/buildbot/filters/lacros.interactive_ui_tests.filter
index 13c5339..d7afb27 100644
--- a/testing/buildbot/filters/lacros.interactive_ui_tests.filter
+++ b/testing/buildbot/filters/lacros.interactive_ui_tests.filter

@@ -43,3 +43,13 @@
 -ToolbarActionViewInteractiveUITest*

 -WidgetCaptureTest.SystemModalWindowReleasesCapture

 -WidgetInputMethodInteractiveTest*

+

+# crbug.com/1121486

+# Following tests were flaky. We disable them first until we have time to investigate.

+-BrowserCommandControllerInteractiveTest.ShortcutsShouldTakeEffectInBrowserFullscreen

+-ExtensionApiTest.DisplayModeWindowIsInFullscreen

+-ExtensionCrashRecoveryTest.TwoExtensionsReloadIndependently

+-KeyboardLockInteractiveBrowserTest.SubsequentLockCallSupersedesPreviousCall

+-NewTabPageDoodleShareDialogFocusTest.All

+-PlatformNotificationServiceBrowserTest.TestShouldDisplayMultiFullscreen

+-PopupBlockerBrowserTest.BlockWebContentsCreationIncognito


diff --git a/testing/buildbot/filters/ozone-linux.wayland_browser_tests.filter b/testing/buildbot/filters/ozone-linux.wayland_browser_tests.filter
index 1ea8db6..777648ef 100644
--- a/testing/buildbot/filters/ozone-linux.wayland_browser_tests.filter
+++ b/testing/buildbot/filters/ozone-linux.wayland_browser_tests.filter

@@ -3,6 +3,7 @@
 # Failed:
 -All/PopupBrowserTest.MoveClampedToCurrentDisplay/0
 -All/PopupBrowserTest.MoveClampedToCurrentDisplay/1
+-AutomationManagerAuraBrowserTest.EventFromAction
 -AutomationManagerAuraBrowserTest.TransientFocusChangesAreSuppressed
 -BrowserActionApiTest.BrowserActionOpenPopupOnPopup
 -BrowserViewTest.F6CyclesThroughCaptionBubbleToo

diff --git a/testing/buildbot/test_suite_exceptions.pyl b/testing/buildbot/test_suite_exceptions.pyl
index 7c58b5a..1d49287 100644
--- a/testing/buildbot/test_suite_exceptions.pyl
+++ b/testing/buildbot/test_suite_exceptions.pyl

@@ -175,9 +175,7 @@
         'swarming': {
           'dimension_sets': [
             {
-              # Run the layout tests on a consistent set of hardware
-              # (Mac Minis).
-              'gpu': '8086:0a2e',
+              'gpu': None,
             },
           ],
           'shards': 25,

diff --git a/testing/variations/fieldtrial_testing_config.json b/testing/variations/fieldtrial_testing_config.json
index 060e2ae..68d89734 100644
--- a/testing/variations/fieldtrial_testing_config.json
+++ b/testing/variations/fieldtrial_testing_config.json

@@ -1911,25 +1911,6 @@
             ]
         }
     ],
-    "DisableLatencyRecoveryDesktop": [
-        {
-            "platforms": [
-                "chromeos",
-                "linux",
-                "mac",
-                "windows"
-            ],
-            "experiments": [
-                {
-                    "name": "DisabledImplDisabledMain",
-                    "disable_features": [
-                        "ImplLatencyRecovery",
-                        "MainLatencyRecovery"
-                    ]
-                }
-            ]
-        }
-    ],
     "DisableMalwareExtensionsRemotely": [
         {
             "platforms": [
@@ -2123,12 +2104,12 @@
                 {
                     "name": "Enabled",
                     "params": {
-                        "BlockExtensionList": "mix_dl_blocked_for_testing",
-                        "SilentBlockExtensionList": "mix_dl_silently_blocked_for_testing",
+                        "BlockExtensionList": "",
+                        "SilentBlockExtensionList": "exe,scr,msi,vb,dmg,pkg,crx",
                         "TreatBlockListAsAllowlist": "false",
                         "TreatSilentBlockListAsAllowlist": "false",
                         "TreatWarnListAsAllowlist": "false",
-                        "WarnExtensionList": "exe,scr,msi,vb,dmg,pkg,crx"
+                        "WarnExtensionList": "zip,iso,rar,7z,tar,gz,bz2"
                     },
                     "enable_features": [
                         "TreatUnsafeDownloadsAsActive"
@@ -2568,6 +2549,27 @@
             ]
         }
     ],
+    "FlocIdComputedEventLogging": [
+        {
+            "platforms": [
+                "android",
+                "android_webview",
+                "chromeos",
+                "ios",
+                "linux",
+                "mac",
+                "windows"
+            ],
+            "experiments": [
+                {
+                    "name": "Enabled",
+                    "enable_features": [
+                        "FlocIdComputedEventLogging"
+                    ]
+                }
+            ]
+        }
+    ],
     "FontSrcLocalMatching": [
         {
             "platforms": [
@@ -3980,21 +3982,6 @@
             ]
         }
     ],
-    "MacCustomPaperSize": [
-        {
-            "platforms": [
-                "mac"
-            ],
-            "experiments": [
-                {
-                    "name": "Enabled",
-                    "enable_features": [
-                        "EnableCustomMacPaperSizes"
-                    ]
-                }
-            ]
-        }
-    ],
     "MacSystemMediaPermissionsInfoUI": [
         {
             "platforms": [

diff --git a/third_party/blink/common/features.cc b/third_party/blink/common/features.cc
index 959556f4..35268351 100644
--- a/third_party/blink/common/features.cc
+++ b/third_party/blink/common/features.cc

@@ -692,11 +692,6 @@
 const base::Feature kCrOSAutoSelect{"CrOSAutoSelect",
                                     base::FEATURE_DISABLED_BY_DEFAULT};
 
-// Enables compositing of eligible SVG elements to improve animation
-// performance. See crbug.com/1101002.
-const base::Feature kCompositeSVG{"CompositeSVG",
-                                  base::FEATURE_DISABLED_BY_DEFAULT};
-
 const base::Feature kCompositingOptimizations{
     "CompositingOptimizations", base::FEATURE_DISABLED_BY_DEFAULT};
 

diff --git a/third_party/blink/public/common/features.h b/third_party/blink/public/common/features.h
index 19471ff..edba1c2 100644
--- a/third_party/blink/public/common/features.h
+++ b/third_party/blink/public/common/features.h

@@ -277,7 +277,6 @@
 
 BLINK_COMMON_EXPORT extern const base::Feature kCrOSAutoSelect;
 
-BLINK_COMMON_EXPORT extern const base::Feature kCompositeSVG;
 BLINK_COMMON_EXPORT extern const base::Feature kCompositingOptimizations;
 
 BLINK_COMMON_EXPORT extern const base::Feature kReducedReferrerGranularity;

diff --git a/third_party/blink/public/mojom/BUILD.gn b/third_party/blink/public/mojom/BUILD.gn
index f7ea823..5ef67263 100644
--- a/third_party/blink/public/mojom/BUILD.gn
+++ b/third_party/blink/public/mojom/BUILD.gn

@@ -36,7 +36,6 @@
     "clipboard/clipboard.mojom",
     "clipboard/raw_clipboard.mojom",
     "commit_result/commit_result.mojom",
-    "contacts/contacts_manager.mojom",
     "content_index/content_index.mojom",
     "conversions/conversions.mojom",
     "cookie_store/cookie_store.mojom",
@@ -594,6 +593,7 @@
     "blob/blob_url_store.mojom",
     "blob/data_element.mojom",
     "blob/serialized_blob.mojom",
+    "contacts/contacts_manager.mojom",
     "digital_goods/digital_goods.mojom",
     "document_metadata/document_metadata.mojom",
     "font_unique_name_lookup/font_unique_name_lookup.mojom",

diff --git a/third_party/blink/public/platform/web_runtime_features.h b/third_party/blink/public/platform/web_runtime_features.h
index 3303e3c..2811c80 100644
--- a/third_party/blink/public/platform/web_runtime_features.h
+++ b/third_party/blink/public/platform/web_runtime_features.h

@@ -253,7 +253,6 @@
   BLINK_PLATFORM_EXPORT static void EnableConversionMeasurementInfraSupport(
       bool);
 
-  BLINK_PLATFORM_EXPORT static void EnableCompositeSVG(bool);
   BLINK_PLATFORM_EXPORT static void EnableCompositingOptimizations(bool);
 
  private:

diff --git a/third_party/blink/public/web/web_document.h b/third_party/blink/public/web/web_document.h
index 8d80c9e..8a30460 100644
--- a/third_party/blink/public/web/web_document.h
+++ b/third_party/blink/public/web/web_document.h

@@ -104,8 +104,6 @@
   BLINK_EXPORT WebURL CompleteURL(const WebString&) const;
   BLINK_EXPORT WebElement GetElementById(const WebString&) const;
   BLINK_EXPORT WebElement FocusedElement() const;
-  BLINK_EXPORT network::mojom::ReferrerPolicy GetReferrerPolicy() const;
-  BLINK_EXPORT WebString OutgoingReferrer();
 
   // Inserts the given CSS source code as a style sheet in the document.
   BLINK_EXPORT WebStyleSheetKey InsertStyleSheet(

diff --git a/third_party/blink/renderer/controller/BUILD.gn b/third_party/blink/renderer/controller/BUILD.gn
index 9cfeb73..96f16e4 100644
--- a/third_party/blink/renderer/controller/BUILD.gn
+++ b/third_party/blink/renderer/controller/BUILD.gn

@@ -45,6 +45,10 @@
     "memory_usage_monitor.h",
     "performance_manager/renderer_resource_coordinator_impl.cc",
     "performance_manager/renderer_resource_coordinator_impl.h",
+    "performance_manager/v8_per_frame_memory_reporter_impl.cc",
+    "performance_manager/v8_per_frame_memory_reporter_impl.h",
+    "performance_manager/v8_worker_memory_reporter.cc",
+    "performance_manager/v8_worker_memory_reporter.h",
   ]
 
   if (is_linux || is_chromeos) {
@@ -63,13 +67,6 @@
       "oom_intervention_impl.cc",
       "oom_intervention_impl.h",
     ]
-  } else {
-    sources += [
-      "performance_manager/v8_per_frame_memory_reporter_impl.cc",
-      "performance_manager/v8_per_frame_memory_reporter_impl.h",
-      "performance_manager/v8_worker_memory_reporter.cc",
-      "performance_manager/v8_worker_memory_reporter.h",
-    ]
   }
   if (is_win) {
     sources += [
@@ -172,7 +169,11 @@
   visibility = [ "*" ]
   testonly = true
 
-  sources = [ "tests/run_all_tests.cc" ]
+  sources = [
+    "performance_manager/v8_per_frame_memory_reporter_impl_test.cc",
+    "performance_manager/v8_worker_memory_reporter_test.cc",
+    "tests/run_all_tests.cc",
+  ]
   sources += bindings_unittest_files
   if (is_linux || is_chromeos) {
     sources += [ "memory_usage_monitor_posix_test.cc" ]
@@ -183,11 +184,6 @@
       "oom_intervention_impl_test.cc",
       "user_level_memory_pressure_signal_generator_test.cc",
     ]
-  } else {
-    sources += [
-      "performance_manager/v8_per_frame_memory_reporter_impl_test.cc",
-      "performance_manager/v8_worker_memory_reporter_test.cc",
-    ]
   }
 
   if (is_linux || is_chromeos || is_android || is_mac || is_win) {

diff --git a/third_party/blink/renderer/controller/blink_initializer.cc b/third_party/blink/renderer/controller/blink_initializer.cc
index b916885..0dc79dba 100644
--- a/third_party/blink/renderer/controller/blink_initializer.cc
+++ b/third_party/blink/renderer/controller/blink_initializer.cc

@@ -46,6 +46,7 @@
 #include "third_party/blink/renderer/controller/blink_leak_detector.h"
 #include "third_party/blink/renderer/controller/dev_tools_frontend_impl.h"
 #include "third_party/blink/renderer/controller/performance_manager/renderer_resource_coordinator_impl.h"
+#include "third_party/blink/renderer/controller/performance_manager/v8_per_frame_memory_reporter_impl.h"
 #include "third_party/blink/renderer/core/animation/animation_clock.h"
 #include "third_party/blink/renderer/core/dom/document.h"
 #include "third_party/blink/renderer/core/execution_context/agent.h"
@@ -64,8 +65,6 @@
 #if defined(OS_ANDROID)
 #include "third_party/blink/renderer/controller/crash_memory_metrics_reporter_impl.h"
 #include "third_party/blink/renderer/controller/oom_intervention_impl.h"
-#else
-#include "third_party/blink/renderer/controller/performance_manager/v8_per_frame_memory_reporter_impl.h"
 #endif
 
 #if defined(OS_LINUX) || defined(OS_CHROMEOS)
@@ -209,12 +208,6 @@
   binders.Add(ConvertToBaseRepeatingCallback(CrossThreadBindRepeating(
                   &CrashMemoryMetricsReporterImpl::Bind)),
               main_thread->GetTaskRunner());
-#else
-  // Currently nothing on Android samples V8PerFrameMemory, so only initialize
-  // the reporter on desktop to save memory.
-  binders.Add(ConvertToBaseRepeatingCallback(CrossThreadBindRepeating(
-                  &V8PerFrameMemoryReporterImpl::Create)),
-              main_thread->GetTaskRunner());
 #endif
 
 #if defined(OS_LINUX) || defined(OS_CHROMEOS)
@@ -230,6 +223,10 @@
   binders.Add(ConvertToBaseRepeatingCallback(
                   CrossThreadBindRepeating(&DiskDataAllocator::Bind)),
               main_thread->GetTaskRunner());
+
+  binders.Add(ConvertToBaseRepeatingCallback(CrossThreadBindRepeating(
+                  &V8PerFrameMemoryReporterImpl::Create)),
+              main_thread->GetTaskRunner());
 }
 
 void BlinkInitializer::InitLocalFrame(LocalFrame& frame) const {

diff --git a/third_party/blink/renderer/core/exported/web_document.cc b/third_party/blink/renderer/core/exported/web_document.cc
index a36b8a11..137b8fa1 100644
--- a/third_party/blink/renderer/core/exported/web_document.cc
+++ b/third_party/blink/renderer/core/exported/web_document.cc

@@ -93,7 +93,9 @@
 
 bool WebDocument::IsSecureContext() const {
   const Document* document = ConstUnwrap<Document>();
-  return document && document->GetExecutionContext()->IsSecureContext();
+  ExecutionContext* context =
+      document ? document->GetExecutionContext() : nullptr;
+  return context && context->IsSecureContext();
 }
 
 WebString WebDocument::Encoding() const {
@@ -235,15 +237,6 @@
   CSSSelectorWatch::From(*document).WatchCSSSelectors(selectors);
 }
 
-network::mojom::ReferrerPolicy WebDocument::GetReferrerPolicy() const {
-  return ConstUnwrap<Document>()->GetExecutionContext()->GetReferrerPolicy();
-}
-
-WebString WebDocument::OutgoingReferrer() {
-  return WebString(
-      Unwrap<Document>()->GetExecutionContext()->OutgoingReferrer());
-}
-
 WebVector<WebDraggableRegion> WebDocument::DraggableRegions() const {
   WebVector<WebDraggableRegion> draggable_regions;
   const Document* document = ConstUnwrap<Document>();

diff --git a/third_party/blink/renderer/core/layout/layout_grid.cc b/third_party/blink/renderer/core/layout/layout_grid.cc
index bc21c55..bd03976 100644
--- a/third_party/blink/renderer/core/layout/layout_grid.cc
+++ b/third_party/blink/renderer/core/layout/layout_grid.cc

@@ -304,6 +304,8 @@
     LayoutUnit available_space_for_columns = AvailableLogicalWidth();
     PlaceItemsOnGrid(track_sizing_algorithm_, available_space_for_columns);
 
+    track_sizing_algorithm_.SetAvailableSpace(kForColumns,
+                                              available_space_for_columns);
     PerformGridItemsPreLayout(track_sizing_algorithm_);
 
     // 1- First, the track sizing algorithm is used to resolve the sizes of the

diff --git a/third_party/blink/renderer/core/loader/frame_loader.cc b/third_party/blink/renderer/core/loader/frame_loader.cc
index 72421a92..3cb54cd 100644
--- a/third_party/blink/renderer/core/loader/frame_loader.cc
+++ b/third_party/blink/renderer/core/loader/frame_loader.cc

@@ -1021,8 +1021,14 @@
     base::AutoReset<bool> scoped_committing(&committing_navigation_, true);
 
     progress_tracker_->ProgressStarted();
-    frame_->GetFrameScheduler()->DidStartProvisionalLoad(frame_->IsMainFrame());
-    probe::DidStartProvisionalLoad(frame_);
+    // In DocumentLoader, the matching DidCommitLoad messages are only called
+    // for kRegular commits. Skip them here, too, to ensure we match
+    // start/commit message pairs.
+    if (commit_reason == CommitReason::kRegular) {
+      frame_->GetFrameScheduler()->DidStartProvisionalLoad(
+          frame_->IsMainFrame());
+      probe::DidStartProvisionalLoad(frame_);
+    }
 
     DCHECK(Client()->HasWebView());
     scoped_refptr<SecurityOrigin> security_origin =

diff --git a/third_party/blink/renderer/core/page/chrome_client_impl.cc b/third_party/blink/renderer/core/page/chrome_client_impl.cc
index a923d3b..5b2ace3 100644
--- a/third_party/blink/renderer/core/page/chrome_client_impl.cc
+++ b/third_party/blink/renderer/core/page/chrome_client_impl.cc

@@ -238,9 +238,7 @@
                                      const SkBitmap& drag_image,
                                      const gfx::Point& drag_image_offset) {
   WebLocalFrameImpl* web_frame = WebLocalFrameImpl::FromFrame(frame);
-  WebDragData drag = drag_data;
-  drag.SetReferrerPolicy(web_frame->GetDocument().GetReferrerPolicy());
-  web_frame->LocalRootFrameWidget()->StartDragging(drag, mask, drag_image,
+  web_frame->LocalRootFrameWidget()->StartDragging(drag_data, mask, drag_image,
                                                    drag_image_offset);
 }
 

diff --git a/third_party/blink/renderer/core/page/drag_controller.cc b/third_party/blink/renderer/core/page/drag_controller.cc
index a01e72f..4a98779 100644
--- a/third_party/blink/renderer/core/page/drag_controller.cc
+++ b/third_party/blink/renderer/core/page/drag_controller.cc

@@ -1334,6 +1334,7 @@
   IntSize offset_size(adjusted_event_pos - adjusted_drag_location);
   gfx::Point offset_point(offset_size.Width(), offset_size.Height());
   WebDragData drag_data = data_transfer->GetDataObject()->ToWebDragData();
+  drag_data.SetReferrerPolicy(drag_initiator_->GetReferrerPolicy());
   WebDragOperationsMask drag_operation_mask =
       static_cast<WebDragOperationsMask>(data_transfer->SourceOperation());
   SkBitmap drag_image;

diff --git a/third_party/blink/renderer/platform/exported/web_runtime_features.cc b/third_party/blink/renderer/platform/exported/web_runtime_features.cc
index efdea67..ac930690 100644
--- a/third_party/blink/renderer/platform/exported/web_runtime_features.cc
+++ b/third_party/blink/renderer/platform/exported/web_runtime_features.cc

@@ -717,10 +717,6 @@
   RuntimeEnabledFeatures::SetRestrictGamepadAccessEnabled(enable);
 }
 
-void WebRuntimeFeatures::EnableCompositeSVG(bool enable) {
-  RuntimeEnabledFeatures::SetCompositeSVGEnabled(enable);
-}
-
 void WebRuntimeFeatures::EnableCompositingOptimizations(bool enable) {
   RuntimeEnabledFeatures::SetCompositingOptimizationsEnabled(enable);
 }

diff --git a/third_party/blink/renderer/platform/runtime_enabled_features.json5 b/third_party/blink/renderer/platform/runtime_enabled_features.json5
index 135264b..dd91417 100644
--- a/third_party/blink/renderer/platform/runtime_enabled_features.json5
+++ b/third_party/blink/renderer/platform/runtime_enabled_features.json5

@@ -334,6 +334,7 @@
     },
     {
       name: "CompositeSVG",
+      status: "experimental"
     },
     {
       name: "CompositingOptimizations",

diff --git a/third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl.cc b/third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl.cc
index cae3c682..eaa796d0 100644
--- a/third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl.cc
+++ b/third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl.cc

@@ -695,12 +695,10 @@
   }
 
   auto insert_result = task_runners_.emplace(task_queue, std::move(voter));
-  auto queue_class = task_queue->queue_class();
 
-  UpdateTaskQueueState(
-      task_queue.get(), insert_result.first->second.get(), TaskQueuePolicy(),
-      main_thread_only().current_policy.GetQueuePolicy(queue_class),
-      /*should_update_priority=*/true);
+  UpdateTaskQueueState(task_queue.get(), insert_result.first->second.get(),
+                       Policy(), main_thread_only().current_policy,
+                       /*should_update_priority=*/true);
 
   // If this is a timer queue, and virtual time is enabled and paused, it should
   // be suspended by adding a fence to prevent immediate tasks from running when
@@ -718,8 +716,8 @@
 scoped_refptr<MainThreadTaskQueue> MainThreadSchedulerImpl::NewLoadingTaskQueue(
     MainThreadTaskQueue::QueueType queue_type,
     FrameSchedulerImpl* frame_scheduler) {
-  DCHECK_EQ(MainThreadTaskQueue::QueueClassForQueueType(queue_type),
-            MainThreadTaskQueue::QueueClass::kLoading);
+  DCHECK(queue_type == MainThreadTaskQueue::QueueType::kFrameLoading ||
+         queue_type == MainThreadTaskQueue::QueueType::kFrameLoadingControl);
   return NewTaskQueue(MainThreadTaskQueue::QueueCreationParams(queue_type)
                           .SetCanBePaused(true)
                           .SetCanBeFrozen(true)
@@ -1454,8 +1452,7 @@
 
     case UseCase::kTouchstart:
       new_policy.rail_mode() = RAILMode::kResponse;
-      new_policy.loading_queue_policy().is_deferred = true;
-      new_policy.default_queue_policy().is_deferred = true;
+      new_policy.should_defer_task_queues() = true;
       break;
 
     case UseCase::kNone:
@@ -1484,18 +1481,13 @@
   if (main_thread_only().renderer_hidden)
     new_policy.rail_mode() = RAILMode::kIdle;
 
-  if (main_thread_only().renderer_pause_count != 0) {
-    new_policy.loading_queue_policy().is_paused = true;
-    new_policy.default_queue_policy().is_paused = true;
-  }
-  if (main_thread_only().pause_timers_for_webview) {
-    new_policy.default_queue_policy().is_paused = true;
+  if (main_thread_only().renderer_pause_count != 0 ||
+      main_thread_only().pause_timers_for_webview) {
+    new_policy.should_pause_task_queues() = true;
   }
 
   if (main_thread_only().use_virtual_time) {
-    new_policy.compositor_queue_policy().use_virtual_time = true;
-    new_policy.default_queue_policy().use_virtual_time = true;
-    new_policy.loading_queue_policy().use_virtual_time = true;
+    new_policy.use_virtual_time() = true;
   }
 
   if (scheduling_settings_
@@ -1566,12 +1558,8 @@
       !previous_policy.has_value() ||
       ShouldUpdateTaskQueuePriorities(previous_policy.value());
   for (const auto& pair : task_runners_) {
-    MainThreadTaskQueue::QueueClass queue_class = pair.first->queue_class();
-
-    UpdateTaskQueueState(pair.first.get(), pair.second.get(),
-                         old_policy.GetQueuePolicy(queue_class),
-                         current_policy.GetQueuePolicy(queue_class),
-                         should_update_priorities);
+    UpdateTaskQueueState(pair.first.get(), pair.second.get(), old_policy,
+                         current_policy, should_update_priorities);
   }
   compositor_task_queue_enabled_voter_->SetVoteToEnable(
       !current_policy.should_freeze_compositor_task_queue());
@@ -1580,31 +1568,25 @@
 void MainThreadSchedulerImpl::UpdateTaskQueueState(
     MainThreadTaskQueue* task_queue,
     TaskQueue::QueueEnabledVoter* task_queue_enabled_voter,
-    const TaskQueuePolicy& old_task_queue_policy,
-    const TaskQueuePolicy& new_task_queue_policy,
+    const Policy& old_policy,
+    const Policy& new_policy,
     bool should_update_priority) const {
   if (should_update_priority)
     task_queue->SetQueuePriority(ComputePriority(task_queue));
 
-  DCHECK(old_task_queue_policy.IsQueueEnabled(task_queue) ||
-         task_queue_enabled_voter);
   if (task_queue_enabled_voter) {
     bool is_enabled_for_agent =
         agent_scheduling_strategy_->QueueEnabledState(*task_queue)
             .value_or(true);
     task_queue_enabled_voter->SetVoteToEnable(
-        is_enabled_for_agent &&
-        new_task_queue_policy.IsQueueEnabled(task_queue));
+        is_enabled_for_agent && new_policy.IsQueueEnabled(task_queue));
   }
 
   // Make sure if there's no voter that the task queue is enabled.
-  DCHECK(task_queue_enabled_voter ||
-         old_task_queue_policy.IsQueueEnabled(task_queue));
+  DCHECK(task_queue_enabled_voter || old_policy.IsQueueEnabled(task_queue));
 
-  TimeDomainType old_time_domain_type =
-      old_task_queue_policy.GetTimeDomainType(task_queue);
-  TimeDomainType new_time_domain_type =
-      new_task_queue_policy.GetTimeDomainType(task_queue);
+  TimeDomainType old_time_domain_type = old_policy.GetTimeDomainType();
+  TimeDomainType new_time_domain_type = new_policy.GetTimeDomainType();
 
   if (old_time_domain_type != new_time_domain_type) {
     if (new_time_domain_type == TimeDomainType::kVirtual) {
@@ -2046,33 +2028,22 @@
   state->EndDictionary();
 }
 
-bool MainThreadSchedulerImpl::TaskQueuePolicy::IsQueueEnabled(
+bool MainThreadSchedulerImpl::Policy::IsQueueEnabled(
     MainThreadTaskQueue* task_queue) const {
-  if (!is_enabled)
+  if (should_pause_task_queues() && task_queue->CanBePaused())
     return false;
-  if (is_paused && task_queue->CanBePaused())
-    return false;
-  if (is_deferred && task_queue->CanBeDeferred())
+  if (should_defer_task_queues() && task_queue->CanBeDeferred())
     return false;
   return true;
 }
 
 MainThreadSchedulerImpl::TimeDomainType
-MainThreadSchedulerImpl::TaskQueuePolicy::GetTimeDomainType(
-    MainThreadTaskQueue* task_queue) const {
-  if (use_virtual_time)
+MainThreadSchedulerImpl::Policy::GetTimeDomainType() const {
+  if (use_virtual_time())
     return TimeDomainType::kVirtual;
   return TimeDomainType::kReal;
 }
 
-void MainThreadSchedulerImpl::TaskQueuePolicy::AsValueInto(
-    base::trace_event::TracedValue* state) const {
-  state->SetBoolean("is_enabled", is_enabled);
-  state->SetBoolean("is_paused", is_paused);
-  state->SetBoolean("is_deferred", is_deferred);
-  state->SetBoolean("use_virtual_time", use_virtual_time);
-}
-
 MainThreadSchedulerImpl::Policy::Policy()
     : rail_mode_(RAILMode::kAnimation),
       should_disable_throttling_(false),
@@ -2086,24 +2057,14 @@
 
 void MainThreadSchedulerImpl::Policy::AsValueInto(
     base::trace_event::TracedValue* state) const {
-  state->BeginDictionary("compositor_queue_policy");
-  compositor_queue_policy().AsValueInto(state);
-  state->EndDictionary();
-
-  state->BeginDictionary("loading_queue_policy");
-  loading_queue_policy().AsValueInto(state);
-  state->EndDictionary();
-
-  state->BeginDictionary("default_queue_policy");
-  default_queue_policy().AsValueInto(state);
-  state->EndDictionary();
-
   state->SetString("rail_mode", RAILModeToString(rail_mode()));
   state->SetString("compositor_priority",
                    TaskQueue::PriorityToString(compositor_priority()));
   state->SetString("use_case", UseCaseToString(use_case()));
-
   state->SetBoolean("should_disable_throttling", should_disable_throttling());
+  state->SetBoolean("should_defer_task_queues", should_defer_task_queues());
+  state->SetBoolean("should_pause_task_queues", should_pause_task_queues());
+  state->SetBoolean("use_virtual_time", use_virtual_time());
 }
 
 void MainThreadSchedulerImpl::OnIdlePeriodStarted() {

diff --git a/third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl.h b/third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl.h
index e15972a5..28ea7ac 100644
--- a/third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl.h
+++ b/third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl.h

@@ -474,33 +474,6 @@
   bool IsAnyMainFrameWaitingForFirstContentfulPaint() const;
   bool IsAnyMainFrameWaitingForFirstMeaningfulPaint() const;
 
-  struct TaskQueuePolicy {
-    // Default constructor of TaskQueuePolicy should match behaviour of a
-    // newly-created task queue.
-    TaskQueuePolicy()
-        : is_enabled(true),
-          is_paused(false),
-          is_deferred(false),
-          use_virtual_time(false) {}
-
-    bool is_enabled;
-    bool is_paused;
-    bool is_deferred;
-    bool use_virtual_time;
-
-    bool IsQueueEnabled(MainThreadTaskQueue* task_queue) const;
-
-    TimeDomainType GetTimeDomainType(MainThreadTaskQueue* task_queue) const;
-
-    bool operator==(const TaskQueuePolicy& other) const {
-      return is_enabled == other.is_enabled && is_paused == other.is_paused &&
-             is_deferred == other.is_deferred &&
-             use_virtual_time == other.use_virtual_time;
-    }
-
-    void AsValueInto(base::trace_event::TracedValue* state) const;
-  };
-
   class Policy {
     DISALLOW_NEW();
 
@@ -508,38 +481,6 @@
     Policy();
     ~Policy() = default;
 
-    TaskQueuePolicy& compositor_queue_policy() {
-      return policies_[static_cast<size_t>(
-          MainThreadTaskQueue::QueueClass::kCompositor)];
-    }
-    const TaskQueuePolicy& compositor_queue_policy() const {
-      return policies_[static_cast<size_t>(
-          MainThreadTaskQueue::QueueClass::kCompositor)];
-    }
-
-    TaskQueuePolicy& loading_queue_policy() {
-      return policies_[static_cast<size_t>(
-          MainThreadTaskQueue::QueueClass::kLoading)];
-    }
-    const TaskQueuePolicy& loading_queue_policy() const {
-      return policies_[static_cast<size_t>(
-          MainThreadTaskQueue::QueueClass::kLoading)];
-    }
-
-    TaskQueuePolicy& default_queue_policy() {
-      return policies_[static_cast<size_t>(
-          MainThreadTaskQueue::QueueClass::kNone)];
-    }
-    const TaskQueuePolicy& default_queue_policy() const {
-      return policies_[static_cast<size_t>(
-          MainThreadTaskQueue::QueueClass::kNone)];
-    }
-
-    const TaskQueuePolicy& GetQueuePolicy(
-        MainThreadTaskQueue::QueueClass queue_class) const {
-      return policies_[static_cast<size_t>(queue_class)];
-    }
-
     RAILMode& rail_mode() { return rail_mode_; }
     RAILMode rail_mode() const { return rail_mode_; }
 
@@ -565,6 +506,15 @@
       return should_freeze_compositor_task_queue_;
     }
 
+    bool& should_defer_task_queues() { return should_defer_task_queues_; }
+    bool should_defer_task_queues() const { return should_defer_task_queues_; }
+
+    bool& should_pause_task_queues() { return should_pause_task_queues_; }
+    bool should_pause_task_queues() const { return should_pause_task_queues_; }
+
+    bool& use_virtual_time() { return use_virtual_time_; }
+    bool use_virtual_time() const { return use_virtual_time_; }
+
     base::sequence_manager::TaskQueue::QueuePriority& compositor_priority() {
       return compositor_priority_;
     }
@@ -585,13 +535,16 @@
     UseCase use_case() const { return use_case_; }
 
     bool operator==(const Policy& other) const {
-      return policies_ == other.policies_ && rail_mode_ == other.rail_mode_ &&
+      return rail_mode_ == other.rail_mode_ &&
              should_disable_throttling_ == other.should_disable_throttling_ &&
              frozen_when_backgrounded_ == other.frozen_when_backgrounded_ &&
              should_prioritize_loading_with_compositing_ ==
                  other.should_prioritize_loading_with_compositing_ &&
              should_freeze_compositor_task_queue_ ==
                  other.should_freeze_compositor_task_queue_ &&
+             should_defer_task_queues_ == other.should_defer_task_queues_ &&
+             should_pause_task_queues_ == other.should_pause_task_queues_ &&
+             use_virtual_time_ == other.use_virtual_time_ &&
              compositor_priority_ == other.compositor_priority_ &&
              find_in_page_priority_ == other.find_in_page_priority_ &&
              use_case_ == other.use_case_;
@@ -599,12 +552,19 @@
 
     void AsValueInto(base::trace_event::TracedValue* state) const;
 
+    bool IsQueueEnabled(MainThreadTaskQueue* task_queue) const;
+
+    TimeDomainType GetTimeDomainType() const;
+
    private:
     RAILMode rail_mode_;
     bool should_disable_throttling_;
     bool frozen_when_backgrounded_;
     bool should_prioritize_loading_with_compositing_;
     bool should_freeze_compositor_task_queue_{false};
+    bool should_defer_task_queues_{false};
+    bool should_pause_task_queues_{false};
+    bool use_virtual_time_{false};
 
     // Priority of task queues belonging to the compositor class (Check
     // MainThread::QueueClass).
@@ -613,10 +573,6 @@
     base::sequence_manager::TaskQueue::QueuePriority find_in_page_priority_;
 
     UseCase use_case_;
-
-    std::array<TaskQueuePolicy,
-               static_cast<size_t>(MainThreadTaskQueue::QueueClass::kCount)>
-        policies_;
   };
 
   class TaskDurationMetricTracker;
@@ -741,8 +697,8 @@
       MainThreadTaskQueue* task_queue,
       base::sequence_manager::TaskQueue::QueueEnabledVoter*
           task_queue_enabled_voter,
-      const TaskQueuePolicy& old_task_queue_policy,
-      const TaskQueuePolicy& new_task_queue_policy,
+      const Policy& old_policy,
+      const Policy& new_policy,
       bool should_update_priority) const;
 
   void PauseRendererImpl();

diff --git a/third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl_unittest.cc b/third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl_unittest.cc
index 0909585..a1f66d2 100644
--- a/third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl_unittest.cc
+++ b/third_party/blink/renderer/platform/scheduler/main_thread/main_thread_scheduler_impl_unittest.cc

@@ -3379,12 +3379,12 @@
   scheduler_->PauseTimersForAndroidWebView();
   EnableIdleTasks();
   test_task_runner_->FastForwardUntilNoTasksRemain();
-  EXPECT_THAT(run_order, testing::ElementsAre("D1", "C1", "L1", "I1"));
+  EXPECT_THAT(run_order, testing::ElementsAre("D1", "C1", "I1"));
   // The rest queued tasks fire when the throttleable queues are resumed.
   run_order.clear();
   scheduler_->ResumeTimersForAndroidWebView();
   test_task_runner_->FastForwardUntilNoTasksRemain();
-  EXPECT_THAT(run_order, testing::ElementsAre("T1"));
+  EXPECT_THAT(run_order, testing::ElementsAre("L1", "T1"));
 }
 #endif  // defined(OS_ANDROID)
 

diff --git a/third_party/blink/renderer/platform/scheduler/main_thread/main_thread_task_queue.cc b/third_party/blink/renderer/platform/scheduler/main_thread/main_thread_task_queue.cc
index a15ba518..d1ad03d 100644
--- a/third_party/blink/renderer/platform/scheduler/main_thread/main_thread_task_queue.cc
+++ b/third_party/blink/renderer/platform/scheduler/main_thread/main_thread_task_queue.cc

@@ -100,37 +100,6 @@
   return false;
 }
 
-MainThreadTaskQueue::QueueClass MainThreadTaskQueue::QueueClassForQueueType(
-    QueueType type) {
-  switch (type) {
-    case QueueType::kControl:
-    case QueueType::kDefault:
-    case QueueType::kIdle:
-    case QueueType::kTest:
-    case QueueType::kV8:
-    case QueueType::kNonWaking:
-    case QueueType::kFrameThrottleable:
-    case QueueType::kFrameDeferrable:
-    case QueueType::kFramePausable:
-    case QueueType::kFrameUnpausable:
-    case QueueType::kWebScheduling:
-      return QueueClass::kNone;
-    case QueueType::kFrameLoading:
-    case QueueType::kFrameLoadingControl:
-      return QueueClass::kLoading;
-    case QueueType::kCompositor:
-    case QueueType::kInput:
-      return QueueClass::kCompositor;
-    case QueueType::kDetached:
-    case QueueType::kOther:
-    case QueueType::kCount:
-      DCHECK(false);
-      return QueueClass::kCount;
-  }
-  NOTREACHED();
-  return QueueClass::kNone;
-}
-
 MainThreadTaskQueue::MainThreadTaskQueue(
     std::unique_ptr<internal::TaskQueueImpl> impl,
     const TaskQueue::Spec& spec,
@@ -138,7 +107,6 @@
     MainThreadSchedulerImpl* main_thread_scheduler)
     : TaskQueue(std::move(impl), spec),
       queue_type_(params.queue_type),
-      queue_class_(QueueClassForQueueType(params.queue_type)),
       fixed_priority_(params.fixed_priority),
       queue_traits_(params.queue_traits),
       freeze_when_keep_active_(params.freeze_when_keep_active),

diff --git a/third_party/blink/renderer/platform/scheduler/main_thread/main_thread_task_queue.h b/third_party/blink/renderer/platform/scheduler/main_thread/main_thread_task_queue.h
index 13588ba5..693b30c 100644
--- a/third_party/blink/renderer/platform/scheduler/main_thread/main_thread_task_queue.h
+++ b/third_party/blink/renderer/platform/scheduler/main_thread/main_thread_task_queue.h

@@ -92,18 +92,6 @@
   // the entire main thread.
   static bool IsPerFrameTaskQueue(QueueType);
 
-  // High-level category used by MainThreadScheduler to make scheduling
-  // decisions.
-  enum class QueueClass {
-    kNone = 0,
-    kLoading = 1,
-    kCompositor = 4,
-
-    kCount = 5,
-  };
-
-  static QueueClass QueueClassForQueueType(QueueType type);
-
   using QueueTraitsKeyType = int;
 
   // QueueTraits represent the deferrable, throttleable, pausable, and freezable
@@ -338,8 +326,6 @@
 
   QueueType queue_type() const { return queue_type_; }
 
-  QueueClass queue_class() const { return queue_class_; }
-
   base::Optional<base::sequence_manager::TaskQueue::QueuePriority>
   FixedPriority() const {
     return fixed_priority_;
@@ -431,7 +417,6 @@
   void ClearReferencesToSchedulers();
 
   const QueueType queue_type_;
-  const QueueClass queue_class_;
   const base::Optional<base::sequence_manager::TaskQueue::QueuePriority>
       fixed_priority_;
   const QueueTraits queue_traits_;

diff --git a/third_party/blink/web_tests/ASANExpectations b/third_party/blink/web_tests/ASANExpectations
index d0c2d43..75bf5e4 100644
--- a/third_party/blink/web_tests/ASANExpectations
+++ b/third_party/blink/web_tests/ASANExpectations

@@ -76,3 +76,5 @@
 
 crbug.com/1048597 [ Linux ] virtual/android/fullscreen/video-scrolled-iframe.html [ Pass Timeout ]
 
+# Sheriff 2020-08-25
+crbug.com/1121429 fast/selectors/placeholder-shown-style-update.html [ Pass Crash ]

diff --git a/third_party/blink/web_tests/FlagExpectations/composite-after-paint b/third_party/blink/web_tests/FlagExpectations/composite-after-paint
index 68db8417..b7786c6 100644
--- a/third_party/blink/web_tests/FlagExpectations/composite-after-paint
+++ b/third_party/blink/web_tests/FlagExpectations/composite-after-paint

@@ -40,25 +40,18 @@
 crbug.com/918155 virtual/prefer_compositing_to_lcd_text/scrollbars/overlay-scrollbar-over-child-layer-nested.html [ Pass ]
 paint/invalidation/compositing/subpixel-offset-scaled-transform-composited.html [ Pass ]
 
-# With CompositeAfterPaint and LayoutNGFragmentItem enabled
-crbug.com/1103138 paint/invalidation/compositing/float-under-composited-inline.html [ Pass Crash ]
-
 # Raster invalidation doesn't work for huge layers.
 paint/invalidation/raster-under-invalidation-checking.html [ Failure ]
 
 # No composited scrolling for overflow:hidden (on marquee).
 compositing/overflow/do-not-repaint-if-scrolling-composited-layers.html [ Failure ]
 
-# Passes on bot, timeouts locally.
-virtual/threaded/fast/events/pinch/scroll-visual-viewport-send-boundary-events.html [ Pass Timeout ]
-
 paint/invalidation/media-audio-no-spurious-repaints.html [ Failure ]
 
 # Outline paints incorrectly with columns. Needs LayoutNGBlockFragment.
 crbug.com/1047358 paint/pagination/composited-paginated-outlined-box.html [ Failure ]
 
 compositing/gestures/gesture-tapHighlight-composited-img.html [ Pass Failure ]
-http/tests/images/image-decode-in-frame.html [ Pass Failure ]
 
 # CompositeAfterPaint positions and scales root scrollbars incorrectly when
 # a page scale factor is applied.

diff --git a/third_party/blink/web_tests/NeverFixTests b/third_party/blink/web_tests/NeverFixTests
index 20d1b3ec..d63f877 100644
--- a/third_party/blink/web_tests/NeverFixTests
+++ b/third_party/blink/web_tests/NeverFixTests

@@ -2183,3 +2183,9 @@
 external/wpt/font-access/font_access-enumeration.tentative.https.window.html [ Skip ]
 virtual/font-access/external/wpt/font-access/font_access-blob.tentative.https.window.html [ Pass ]
 virtual/font-access/external/wpt/font-access/font_access-enumeration.tentative.https.window.html [ Pass ]
+
+# text-orientation:upright
+crbug.com/1005518 external/wpt/css/css-writing-modes/table-progression-vlr-003.html [ Skip ]
+crbug.com/1005518 external/wpt/css/css-writing-modes/table-progression-vlr-004.html [ Skip ]
+crbug.com/1005518 external/wpt/css/css-writing-modes/table-progression-vrl-003.html [ Skip ]
+crbug.com/1005518 external/wpt/css/css-writing-modes/table-progression-vrl-004.html [ Skip ]

diff --git a/third_party/blink/web_tests/TestExpectations b/third_party/blink/web_tests/TestExpectations
index 1c5e9b6..35962c0 100644
--- a/third_party/blink/web_tests/TestExpectations
+++ b/third_party/blink/web_tests/TestExpectations

@@ -178,6 +178,9 @@
 
 crbug.com/829740 fast/history/history-back-twice-with-subframes-assert.html [ Pass Timeout ]
 
+# CompositeSVG subpixel differences
+crbug.com/1120920 external/wpt/css/compositing/svg/mix-blend-mode-svg-rectangle.html [ Failure ]
+
 ########## Genuinely flaky ##########
 crbug.com/624233 virtual/gpu-rasterization/images/color-profile-background-clip-text.html [ Pass Failure ]
 
@@ -1808,10 +1811,6 @@
 crbug.com/1020373 external/wpt/css/css-writing-modes/line-box-direction-vrl-015.xht [ Failure ]
 crbug.com/1020373 external/wpt/css/css-writing-modes/table-cell-001.html [ Failure ]
 crbug.com/1020373 external/wpt/css/css-writing-modes/table-cell-002.html [ Failure ]
-crbug.com/1020373 external/wpt/css/css-writing-modes/table-progression-vlr-003.html [ Failure ]
-crbug.com/1020373 external/wpt/css/css-writing-modes/table-progression-vlr-004.html [ Failure ]
-crbug.com/1020373 external/wpt/css/css-writing-modes/table-progression-vrl-003.html [ Failure ]
-crbug.com/1020373 external/wpt/css/css-writing-modes/table-progression-vrl-004.html [ Failure ]
 
 crbug.com/637055 fast/css/outline-offset-large.html [ Skip ]
 
@@ -2626,162 +2625,66 @@
 crbug.com/626703 [ Mac10.14 ] external/wpt/webrtc-insertable-streams/RTCPeerConnection-insertable-streams.https.html [ Timeout ]
 crbug.com/626703 [ Mac10.15 ] external/wpt/webrtc-insertable-streams/RTCPeerConnection-insertable-streams.https.html [ Timeout ]
 crbug.com/626703 external/wpt/content-security-policy/frame-src/frame-src-same-document.sub.html [ Timeout ]
-crbug.com/626703 [ Linux ] external/wpt/input-events/input-events-get-target-ranges-backspace.tentative.html [ Timeout ]
-crbug.com/626703 [ Mac ] external/wpt/input-events/input-events-get-target-ranges-backspace.tentative.html [ Timeout ]
-crbug.com/626703 [ Win ] external/wpt/input-events/input-events-get-target-ranges-backspace.tentative.html [ Timeout ]
-crbug.com/626703 [ Linux ] external/wpt/input-events/input-events-get-target-ranges-forwarddelete.tentative.html [ Timeout ]
-crbug.com/626703 [ Mac ] external/wpt/input-events/input-events-get-target-ranges-forwarddelete.tentative.html [ Timeout ]
-crbug.com/626703 [ Win ] external/wpt/input-events/input-events-get-target-ranges-forwarddelete.tentative.html [ Timeout ]
-crbug.com/626703 [ Linux ] external/wpt/html/semantics/embedded-content/the-iframe-element/iframe_sandbox_navigation_download_allow_downloads.sub.tentative.html [ Timeout ]
-crbug.com/626703 [ Mac ] external/wpt/html/semantics/embedded-content/the-iframe-element/iframe_sandbox_navigation_download_allow_downloads.sub.tentative.html [ Timeout ]
-crbug.com/626703 [ Win ] external/wpt/html/semantics/embedded-content/the-iframe-element/iframe_sandbox_navigation_download_allow_downloads.sub.tentative.html [ Timeout ]
-crbug.com/626703 [ Linux ] external/wpt/streams/transform-streams/patched-global.any.serviceworker.html [ Timeout ]
-crbug.com/626703 [ Mac ] external/wpt/streams/transform-streams/patched-global.any.serviceworker.html [ Timeout ]
-crbug.com/626703 [ Win ] external/wpt/streams/transform-streams/patched-global.any.serviceworker.html [ Timeout ]
-crbug.com/626703 [ Linux ] external/wpt/streams/transform-streams/patched-global.any.worker.html [ Timeout ]
-crbug.com/626703 [ Mac ] external/wpt/streams/transform-streams/patched-global.any.worker.html [ Timeout ]
-crbug.com/626703 [ Win ] external/wpt/streams/transform-streams/patched-global.any.worker.html [ Timeout ]
-crbug.com/626703 [ Linux ] external/wpt/streams/transform-streams/patched-global.any.sharedworker.html [ Timeout ]
-crbug.com/626703 [ Mac ] external/wpt/streams/transform-streams/patched-global.any.sharedworker.html [ Timeout ]
-crbug.com/626703 [ Win ] external/wpt/streams/transform-streams/patched-global.any.sharedworker.html [ Timeout ]
+crbug.com/626703 external/wpt/input-events/input-events-get-target-ranges-backspace.tentative.html [ Timeout ]
+crbug.com/626703 external/wpt/input-events/input-events-get-target-ranges-forwarddelete.tentative.html [ Timeout ]
+crbug.com/626703 external/wpt/html/semantics/embedded-content/the-iframe-element/iframe_sandbox_navigation_download_allow_downloads.sub.tentative.html [ Timeout ]
+crbug.com/626703 external/wpt/streams/transform-streams/patched-global.any.serviceworker.html [ Timeout ]
+crbug.com/626703 external/wpt/streams/transform-streams/patched-global.any.worker.html [ Timeout ]
+crbug.com/626703 external/wpt/streams/transform-streams/patched-global.any.sharedworker.html [ Timeout ]
 crbug.com/626703 [ Linux ] external/wpt/css/css-color/t422-rgba-a0.6-a.xht [ Failure ]
-crbug.com/626703 [ Linux ] external/wpt/css/css-color/t32-opacity-basic-0.6-a.xht [ Failure ]
-crbug.com/626703 [ Mac ] external/wpt/css/css-color/t32-opacity-basic-0.6-a.xht [ Failure ]
-crbug.com/626703 [ Win ] external/wpt/css/css-color/t32-opacity-basic-0.6-a.xht [ Failure ]
+crbug.com/626703 external/wpt/css/css-color/t32-opacity-basic-0.6-a.xht [ Failure ]
 crbug.com/626703 [ Linux ] external/wpt/css/css-color/t425-hsla-basic-a.xht [ Failure ]
-crbug.com/626703 [ Linux ] external/wpt/wasm/jsapi/functions/incumbent.html [ Crash ]
-crbug.com/626703 [ Mac ] external/wpt/wasm/jsapi/functions/incumbent.html [ Crash ]
-crbug.com/626703 [ Win ] external/wpt/wasm/jsapi/functions/incumbent.html [ Crash ]
-crbug.com/626703 [ Linux ] external/wpt/mathml/presentation-markup/fractions/frac-invalid-3.html [ Failure ]
-crbug.com/626703 [ Mac ] external/wpt/mathml/presentation-markup/fractions/frac-invalid-3.html [ Failure ]
-crbug.com/626703 [ Win ] external/wpt/mathml/presentation-markup/fractions/frac-invalid-3.html [ Failure ]
-crbug.com/626703 [ Linux ] external/wpt/mathml/presentation-markup/fractions/frac-invalid-2.html [ Failure ]
-crbug.com/626703 [ Mac ] external/wpt/mathml/presentation-markup/fractions/frac-invalid-2.html [ Failure ]
-crbug.com/626703 [ Win ] external/wpt/mathml/presentation-markup/fractions/frac-invalid-2.html [ Failure ]
-crbug.com/626703 [ Linux ] external/wpt/css/CSS2/normal-flow/min-height-applies-to-014.xht [ Failure ]
-crbug.com/626703 [ Mac ] external/wpt/css/CSS2/normal-flow/min-height-applies-to-014.xht [ Failure ]
-crbug.com/626703 [ Win ] external/wpt/css/CSS2/normal-flow/min-height-applies-to-014.xht [ Failure ]
-crbug.com/626703 [ Linux ] external/wpt/html/semantics/embedded-content/the-iframe-element/iframe_sandbox_allow_top_navigation-1.html [ Timeout ]
-crbug.com/626703 [ Mac ] external/wpt/html/semantics/embedded-content/the-iframe-element/iframe_sandbox_allow_top_navigation-1.html [ Timeout ]
-crbug.com/626703 [ Win ] external/wpt/html/semantics/embedded-content/the-iframe-element/iframe_sandbox_allow_top_navigation-1.html [ Timeout ]
-crbug.com/626703 [ Linux ] external/wpt/html/semantics/embedded-content/the-iframe-element/iframe_sandbox_allow_top_navigation-3.html [ Timeout ]
-crbug.com/626703 [ Mac ] external/wpt/html/semantics/embedded-content/the-iframe-element/iframe_sandbox_allow_top_navigation-3.html [ Timeout ]
-crbug.com/626703 [ Win ] external/wpt/html/semantics/embedded-content/the-iframe-element/iframe_sandbox_allow_top_navigation-3.html [ Timeout ]
+crbug.com/626703 external/wpt/wasm/jsapi/functions/incumbent.html [ Crash ]
+crbug.com/626703 external/wpt/mathml/presentation-markup/fractions/frac-invalid-3.html [ Failure ]
+crbug.com/626703 external/wpt/mathml/presentation-markup/fractions/frac-invalid-2.html [ Failure ]
+crbug.com/626703 external/wpt/css/CSS2/normal-flow/min-height-applies-to-014.xht [ Failure ]
+crbug.com/626703 external/wpt/html/semantics/embedded-content/the-iframe-element/iframe_sandbox_allow_top_navigation-1.html [ Timeout ]
+crbug.com/626703 external/wpt/html/semantics/embedded-content/the-iframe-element/iframe_sandbox_allow_top_navigation-3.html [ Timeout ]
 crbug.com/626703 external/wpt/dom/events/scrolling/scrollend-event-for-user-scroll.html [ Failure Timeout ]
-crbug.com/626703 [ Linux ] external/wpt/webtransport/quic/client-indication.sub.any.html [ Timeout ]
-crbug.com/626703 [ Mac ] external/wpt/webtransport/quic/client-indication.sub.any.html [ Timeout ]
-crbug.com/626703 [ Win ] external/wpt/webtransport/quic/client-indication.sub.any.html [ Timeout ]
+crbug.com/626703 external/wpt/webtransport/quic/client-indication.sub.any.html [ Timeout ]
 crbug.com/626703 [ Mac10.14 ] external/wpt/html/browsers/the-window-object/apis-for-creating-and-navigating-browsing-contexts-by-name/open-features-tokenization-screenx-screeny.html [ Timeout ]
 crbug.com/626703 [ Mac10.15 ] external/wpt/html/browsers/the-window-object/apis-for-creating-and-navigating-browsing-contexts-by-name/open-features-tokenization-innerheight-innerwidth.html [ Timeout ]
 crbug.com/626703 [ Mac10.15 ] external/wpt/webaudio/the-audio-api/the-mediastreamaudiosourcenode-interface/mediastreamaudiosourcenode-routing.html [ Timeout ]
-crbug.com/626703 [ Linux ] external/wpt/workers/Worker-replace-self.any.html [ Timeout ]
-crbug.com/626703 [ Mac ] external/wpt/workers/Worker-replace-self.any.html [ Timeout ]
-crbug.com/626703 [ Win ] external/wpt/workers/Worker-replace-self.any.html [ Timeout ]
-crbug.com/626703 [ Linux ] external/wpt/cookie-store/cookieStoreManager_getSubscriptions_multiple.tentative.https.any.worker.html [ Timeout ]
-crbug.com/626703 [ Mac ] external/wpt/cookie-store/cookieStoreManager_getSubscriptions_multiple.tentative.https.any.worker.html [ Timeout ]
-crbug.com/626703 [ Win ] external/wpt/cookie-store/cookieStoreManager_getSubscriptions_multiple.tentative.https.any.worker.html [ Timeout ]
-crbug.com/626703 [ Linux ] external/wpt/cookie-store/serviceworker_oncookiechange_eventhandler_single_subscription.tentative.https.any.html [ Timeout ]
-crbug.com/626703 [ Mac ] external/wpt/cookie-store/serviceworker_oncookiechange_eventhandler_single_subscription.tentative.https.any.html [ Timeout ]
-crbug.com/626703 [ Win ] external/wpt/cookie-store/serviceworker_oncookiechange_eventhandler_single_subscription.tentative.https.any.html [ Timeout ]
-crbug.com/626703 [ Linux ] external/wpt/cookie-store/cookieStoreManager_getSubscriptions_single.tentative.https.any.worker.html [ Timeout ]
-crbug.com/626703 [ Mac ] external/wpt/cookie-store/cookieStoreManager_getSubscriptions_single.tentative.https.any.worker.html [ Timeout ]
-crbug.com/626703 [ Win ] external/wpt/cookie-store/cookieStoreManager_getSubscriptions_single.tentative.https.any.worker.html [ Timeout ]
-crbug.com/626703 [ Linux ] external/wpt/workers/SharedWorker-replace-EventHandler.any.html [ Timeout ]
-crbug.com/626703 [ Mac ] external/wpt/workers/SharedWorker-replace-EventHandler.any.html [ Timeout ]
-crbug.com/626703 [ Win ] external/wpt/workers/SharedWorker-replace-EventHandler.any.html [ Timeout ]
-crbug.com/626703 [ Linux ] external/wpt/workers/SharedWorker-MessageEvent-source.any.html [ Timeout ]
-crbug.com/626703 [ Mac ] external/wpt/workers/SharedWorker-MessageEvent-source.any.html [ Timeout ]
-crbug.com/626703 [ Win ] external/wpt/workers/SharedWorker-MessageEvent-source.any.html [ Timeout ]
-crbug.com/626703 [ Linux ] external/wpt/workers/examples/onconnect.any.html [ Timeout ]
-crbug.com/626703 [ Mac ] external/wpt/workers/examples/onconnect.any.html [ Timeout ]
-crbug.com/626703 [ Win ] external/wpt/workers/examples/onconnect.any.html [ Timeout ]
-crbug.com/626703 [ Linux ] external/wpt/service-workers/service-worker/global-serviceworker.https.any.html [ Timeout ]
-crbug.com/626703 [ Mac ] external/wpt/service-workers/service-worker/global-serviceworker.https.any.html [ Timeout ]
-crbug.com/626703 [ Win ] external/wpt/service-workers/service-worker/global-serviceworker.https.any.html [ Timeout ]
-crbug.com/626703 [ Linux ] external/wpt/workers/SharedWorker-replace-EventHandler.any.worker.html [ Timeout ]
-crbug.com/626703 [ Mac ] external/wpt/workers/SharedWorker-replace-EventHandler.any.worker.html [ Timeout ]
-crbug.com/626703 [ Win ] external/wpt/workers/SharedWorker-replace-EventHandler.any.worker.html [ Timeout ]
-crbug.com/626703 [ Linux ] external/wpt/cookie-store/serviceworker_cookiechange_eventhandler_mismatched_subscription.tentative.https.any.html [ Timeout ]
-crbug.com/626703 [ Mac ] external/wpt/cookie-store/serviceworker_cookiechange_eventhandler_mismatched_subscription.tentative.https.any.html [ Timeout ]
-crbug.com/626703 [ Win ] external/wpt/cookie-store/serviceworker_cookiechange_eventhandler_mismatched_subscription.tentative.https.any.html [ Timeout ]
-crbug.com/626703 [ Linux ] external/wpt/workers/interfaces/WorkerGlobalScope/self.any.html [ Timeout ]
-crbug.com/626703 [ Mac ] external/wpt/workers/interfaces/WorkerGlobalScope/self.any.html [ Timeout ]
-crbug.com/626703 [ Win ] external/wpt/workers/interfaces/WorkerGlobalScope/self.any.html [ Timeout ]
-crbug.com/626703 [ Linux ] external/wpt/cookie-store/cookieStoreManager_getSubscriptions_empty.tentative.https.any.worker.html [ Timeout ]
-crbug.com/626703 [ Mac ] external/wpt/cookie-store/cookieStoreManager_getSubscriptions_empty.tentative.https.any.worker.html [ Timeout ]
-crbug.com/626703 [ Win ] external/wpt/cookie-store/cookieStoreManager_getSubscriptions_empty.tentative.https.any.worker.html [ Timeout ]
-crbug.com/626703 [ Linux ] external/wpt/cookie-store/serviceworker_cookiechange_eventhandler_single_subscription.tentative.https.any.html [ Timeout ]
-crbug.com/626703 [ Mac ] external/wpt/cookie-store/serviceworker_cookiechange_eventhandler_single_subscription.tentative.https.any.html [ Timeout ]
-crbug.com/626703 [ Win ] external/wpt/cookie-store/serviceworker_cookiechange_eventhandler_single_subscription.tentative.https.any.html [ Timeout ]
-crbug.com/626703 [ Linux ] external/wpt/cookie-store/serviceworker_cookiechange_eventhandler_overlapping_subscriptions.tentative.https.any.html [ Timeout ]
-crbug.com/626703 [ Mac ] external/wpt/cookie-store/serviceworker_cookiechange_eventhandler_overlapping_subscriptions.tentative.https.any.html [ Timeout ]
-crbug.com/626703 [ Win ] external/wpt/cookie-store/serviceworker_cookiechange_eventhandler_overlapping_subscriptions.tentative.https.any.html [ Timeout ]
-crbug.com/626703 [ Linux ] external/wpt/cookie-store/serviceworker_cookiechange_eventhandler_overlapping_subscriptions.tentative.https.any.worker.html [ Timeout ]
-crbug.com/626703 [ Mac ] external/wpt/cookie-store/serviceworker_cookiechange_eventhandler_overlapping_subscriptions.tentative.https.any.worker.html [ Timeout ]
-crbug.com/626703 [ Win ] external/wpt/cookie-store/serviceworker_cookiechange_eventhandler_overlapping_subscriptions.tentative.https.any.worker.html [ Timeout ]
-crbug.com/626703 [ Linux ] external/wpt/cookie-store/serviceworker_cookiechange_eventhandler_mismatched_subscription.tentative.https.any.worker.html [ Timeout ]
-crbug.com/626703 [ Mac ] external/wpt/cookie-store/serviceworker_cookiechange_eventhandler_mismatched_subscription.tentative.https.any.worker.html [ Timeout ]
-crbug.com/626703 [ Win ] external/wpt/cookie-store/serviceworker_cookiechange_eventhandler_mismatched_subscription.tentative.https.any.worker.html [ Timeout ]
-crbug.com/626703 [ Linux ] external/wpt/cookie-store/cookieStore_subscribe_arguments.tentative.https.any.worker.html [ Timeout ]
-crbug.com/626703 [ Mac ] external/wpt/cookie-store/cookieStore_subscribe_arguments.tentative.https.any.worker.html [ Timeout ]
-crbug.com/626703 [ Win ] external/wpt/cookie-store/cookieStore_subscribe_arguments.tentative.https.any.worker.html [ Timeout ]
-crbug.com/626703 [ Linux ] external/wpt/workers/SharedWorker-MessageEvent-source.any.worker.html [ Timeout ]
-crbug.com/626703 [ Mac ] external/wpt/workers/SharedWorker-MessageEvent-source.any.worker.html [ Timeout ]
-crbug.com/626703 [ Win ] external/wpt/workers/SharedWorker-MessageEvent-source.any.worker.html [ Timeout ]
-crbug.com/626703 [ Linux ] external/wpt/cookie-store/serviceworker_cookiechange_eventhandler_multiple_subscriptions.tentative.https.any.html [ Timeout ]
-crbug.com/626703 [ Mac ] external/wpt/cookie-store/serviceworker_cookiechange_eventhandler_multiple_subscriptions.tentative.https.any.html [ Timeout ]
-crbug.com/626703 [ Win ] external/wpt/cookie-store/serviceworker_cookiechange_eventhandler_multiple_subscriptions.tentative.https.any.html [ Timeout ]
-crbug.com/626703 [ Linux ] external/wpt/cookie-store/serviceworker_cookiechange_eventhandler_multiple_subscriptions.tentative.https.any.worker.html [ Timeout ]
-crbug.com/626703 [ Mac ] external/wpt/cookie-store/serviceworker_cookiechange_eventhandler_multiple_subscriptions.tentative.https.any.worker.html [ Timeout ]
-crbug.com/626703 [ Win ] external/wpt/cookie-store/serviceworker_cookiechange_eventhandler_multiple_subscriptions.tentative.https.any.worker.html [ Timeout ]
-crbug.com/626703 [ Linux ] external/wpt/cookie-store/serviceworker_cookiechange_eventhandler_single_subscription.tentative.https.any.worker.html [ Timeout ]
-crbug.com/626703 [ Mac ] external/wpt/cookie-store/serviceworker_cookiechange_eventhandler_single_subscription.tentative.https.any.worker.html [ Timeout ]
-crbug.com/626703 [ Win ] external/wpt/cookie-store/serviceworker_cookiechange_eventhandler_single_subscription.tentative.https.any.worker.html [ Timeout ]
-crbug.com/626703 [ Linux ] external/wpt/service-workers/service-worker/global-serviceworker.https.any.worker.html [ Timeout ]
-crbug.com/626703 [ Mac ] external/wpt/service-workers/service-worker/global-serviceworker.https.any.worker.html [ Timeout ]
-crbug.com/626703 [ Win ] external/wpt/service-workers/service-worker/global-serviceworker.https.any.worker.html [ Timeout ]
-crbug.com/626703 [ Linux ] external/wpt/workers/examples/onconnect.any.worker.html [ Timeout ]
-crbug.com/626703 [ Mac ] external/wpt/workers/examples/onconnect.any.worker.html [ Timeout ]
-crbug.com/626703 [ Win ] external/wpt/workers/examples/onconnect.any.worker.html [ Timeout ]
-crbug.com/626703 [ Linux ] external/wpt/cookie-store/serviceworker_oncookiechange_eventhandler_single_subscription.tentative.https.any.worker.html [ Timeout ]
-crbug.com/626703 [ Mac ] external/wpt/cookie-store/serviceworker_oncookiechange_eventhandler_single_subscription.tentative.https.any.worker.html [ Timeout ]
-crbug.com/626703 [ Win ] external/wpt/cookie-store/serviceworker_oncookiechange_eventhandler_single_subscription.tentative.https.any.worker.html [ Timeout ]
-crbug.com/626703 [ Linux ] external/wpt/workers/postMessage_block.https.html [ Timeout ]
-crbug.com/626703 [ Mac ] external/wpt/workers/postMessage_block.https.html [ Timeout ]
-crbug.com/626703 [ Win ] external/wpt/workers/postMessage_block.https.html [ Timeout ]
-crbug.com/626703 [ Linux ] external/wpt/mathml/relations/css-styling/color-005.html [ Failure ]
-crbug.com/626703 [ Mac ] external/wpt/mathml/relations/css-styling/color-005.html [ Failure ]
-crbug.com/626703 [ Win ] external/wpt/mathml/relations/css-styling/color-005.html [ Failure ]
-crbug.com/626703 [ Linux ] external/wpt/content-security-policy/script-src/script-src-strict_dynamic_double_policy_honor_source_expressions.html [ Timeout ]
-crbug.com/626703 [ Mac ] external/wpt/content-security-policy/script-src/script-src-strict_dynamic_double_policy_honor_source_expressions.html [ Timeout ]
-crbug.com/626703 [ Win ] external/wpt/content-security-policy/script-src/script-src-strict_dynamic_double_policy_honor_source_expressions.html [ Timeout ]
-crbug.com/626703 [ Linux ] external/wpt/uievents/order-of-events/focus-events/focus-management-expectations.html [ Timeout ]
-crbug.com/626703 [ Mac ] external/wpt/uievents/order-of-events/focus-events/focus-management-expectations.html [ Timeout ]
-crbug.com/626703 [ Win ] external/wpt/uievents/order-of-events/focus-events/focus-management-expectations.html [ Timeout ]
-crbug.com/626703 [ Linux ] external/wpt/mathml/presentation-markup/operators/mo-form-dynamic-002.html [ Failure ]
-crbug.com/626703 [ Mac ] external/wpt/mathml/presentation-markup/operators/mo-form-dynamic-002.html [ Failure ]
-crbug.com/626703 [ Win ] external/wpt/mathml/presentation-markup/operators/mo-form-dynamic-002.html [ Failure ]
-crbug.com/626703 [ Linux ] external/wpt/mathml/presentation-markup/operators/mo-lspace-rspace-dynamic.html [ Failure ]
-crbug.com/626703 [ Mac ] external/wpt/mathml/presentation-markup/operators/mo-lspace-rspace-dynamic.html [ Failure ]
-crbug.com/626703 [ Win ] external/wpt/mathml/presentation-markup/operators/mo-lspace-rspace-dynamic.html [ Failure ]
+crbug.com/626703 external/wpt/workers/Worker-replace-self.any.html [ Timeout ]
+crbug.com/626703 external/wpt/cookie-store/cookieStoreManager_getSubscriptions_multiple.tentative.https.any.worker.html [ Timeout ]
+crbug.com/626703 external/wpt/cookie-store/serviceworker_oncookiechange_eventhandler_single_subscription.tentative.https.any.html [ Timeout ]
+crbug.com/626703 external/wpt/cookie-store/cookieStoreManager_getSubscriptions_single.tentative.https.any.worker.html [ Timeout ]
+crbug.com/626703 external/wpt/workers/SharedWorker-replace-EventHandler.any.html [ Timeout ]
+crbug.com/626703 external/wpt/workers/SharedWorker-MessageEvent-source.any.html [ Timeout ]
+crbug.com/626703 external/wpt/workers/examples/onconnect.any.html [ Timeout ]
+crbug.com/626703 external/wpt/service-workers/service-worker/global-serviceworker.https.any.html [ Timeout ]
+crbug.com/626703 external/wpt/workers/SharedWorker-replace-EventHandler.any.worker.html [ Timeout ]
+crbug.com/626703 external/wpt/cookie-store/serviceworker_cookiechange_eventhandler_mismatched_subscription.tentative.https.any.html [ Timeout ]
+crbug.com/626703 external/wpt/workers/interfaces/WorkerGlobalScope/self.any.html [ Timeout ]
+crbug.com/626703 external/wpt/cookie-store/cookieStoreManager_getSubscriptions_empty.tentative.https.any.worker.html [ Timeout ]
+crbug.com/626703 external/wpt/cookie-store/serviceworker_cookiechange_eventhandler_single_subscription.tentative.https.any.html [ Timeout ]
+crbug.com/626703 external/wpt/cookie-store/serviceworker_cookiechange_eventhandler_overlapping_subscriptions.tentative.https.any.html [ Timeout ]
+crbug.com/626703 external/wpt/cookie-store/serviceworker_cookiechange_eventhandler_overlapping_subscriptions.tentative.https.any.worker.html [ Timeout ]
+crbug.com/626703 external/wpt/cookie-store/serviceworker_cookiechange_eventhandler_mismatched_subscription.tentative.https.any.worker.html [ Timeout ]
+crbug.com/626703 external/wpt/cookie-store/cookieStore_subscribe_arguments.tentative.https.any.worker.html [ Timeout ]
+crbug.com/626703 external/wpt/workers/SharedWorker-MessageEvent-source.any.worker.html [ Timeout ]
+crbug.com/626703 external/wpt/cookie-store/serviceworker_cookiechange_eventhandler_multiple_subscriptions.tentative.https.any.html [ Timeout ]
+crbug.com/626703 external/wpt/cookie-store/serviceworker_cookiechange_eventhandler_multiple_subscriptions.tentative.https.any.worker.html [ Timeout ]
+crbug.com/626703 external/wpt/cookie-store/serviceworker_cookiechange_eventhandler_single_subscription.tentative.https.any.worker.html [ Timeout ]
+crbug.com/626703 external/wpt/service-workers/service-worker/global-serviceworker.https.any.worker.html [ Timeout ]
+crbug.com/626703 external/wpt/workers/examples/onconnect.any.worker.html [ Timeout ]
+crbug.com/626703 external/wpt/cookie-store/serviceworker_oncookiechange_eventhandler_single_subscription.tentative.https.any.worker.html [ Timeout ]
+crbug.com/626703 external/wpt/workers/postMessage_block.https.html [ Timeout ]
+crbug.com/626703 external/wpt/mathml/relations/css-styling/color-005.html [ Failure ]
+crbug.com/626703 external/wpt/content-security-policy/script-src/script-src-strict_dynamic_double_policy_honor_source_expressions.html [ Timeout ]
+crbug.com/626703 external/wpt/uievents/order-of-events/focus-events/focus-management-expectations.html [ Timeout ]
+crbug.com/626703 external/wpt/mathml/presentation-markup/operators/mo-form-dynamic-002.html [ Failure ]
+crbug.com/626703 external/wpt/mathml/presentation-markup/operators/mo-lspace-rspace-dynamic.html [ Failure ]
 crbug.com/626703 [ Mac10.14 ] external/wpt/webrtc/RTCRtpSender-replaceTrack.https.html [ Timeout ]
 crbug.com/626703 [ Win ] external/wpt/webrtc/RTCRtpSender-replaceTrack.https.html [ Timeout ]
 crbug.com/626703 [ Mac10.14 ] external/wpt/preload/onload-event.html [ Timeout ]
 crbug.com/626703 [ Mac10.14 ] external/wpt/preload/download-resources.html [ Timeout ]
 crbug.com/626703 [ Mac10.12 ] external/wpt/css/css-fonts/matching/range-descriptor-reversed.html [ Failure ]
-crbug.com/626703 [ Linux ] external/wpt/workers/shared-worker-parse-error-failure.html [ Timeout ]
-crbug.com/626703 [ Mac ] external/wpt/workers/shared-worker-parse-error-failure.html [ Timeout ]
-crbug.com/626703 [ Win ] external/wpt/workers/shared-worker-parse-error-failure.html [ Timeout ]
-crbug.com/626703 [ Linux ] external/wpt/webrtc/RTCPeerConnection-operations.https.html [ Timeout ]
-crbug.com/626703 [ Mac ] external/wpt/webrtc/RTCPeerConnection-operations.https.html [ Timeout ]
-crbug.com/626703 [ Win ] external/wpt/webrtc/RTCPeerConnection-operations.https.html [ Timeout ]
-crbug.com/626703 [ Linux ] external/wpt/content-dpr/content-dpr-various-elements.html [ Failure ]
-crbug.com/626703 [ Mac ] external/wpt/content-dpr/content-dpr-various-elements.html [ Failure ]
-crbug.com/626703 [ Win ] external/wpt/content-dpr/content-dpr-various-elements.html [ Failure ]
+crbug.com/626703 external/wpt/workers/shared-worker-parse-error-failure.html [ Timeout ]
+crbug.com/626703 external/wpt/webrtc/RTCPeerConnection-operations.https.html [ Timeout ]
+crbug.com/626703 external/wpt/content-dpr/content-dpr-various-elements.html [ Failure ]
 crbug.com/626703 [ Mac10.14 ] external/wpt/html/browsers/the-window-object/apis-for-creating-and-navigating-browsing-contexts-by-name/open-features-tokenization-top-left.html [ Timeout ]
-crbug.com/626703 [ Linux ] external/wpt/workers/abrupt-completion.html [ Timeout ]
-crbug.com/626703 [ Mac ] external/wpt/workers/abrupt-completion.html [ Timeout ]
-crbug.com/626703 [ Win ] external/wpt/workers/abrupt-completion.html [ Timeout ]
+crbug.com/626703 external/wpt/workers/abrupt-completion.html [ Timeout ]
 crbug.com/626703 [ Mac10.12 ] external/wpt/eventsource/eventsource-constructor-url-bogus.any.html [ Failure Timeout ]
 crbug.com/626703 [ Mac10.12 ] external/wpt/html/webappapis/scripting/events/event-handler-attributes-body-window.html [ Failure Timeout ]
 crbug.com/626703 [ Mac10.12 ] external/wpt/WebCryptoAPI/derive_bits_keys/hkdf.https.any.html?1-1000 [ Failure Timeout ]
@@ -2792,9 +2695,7 @@
 crbug.com/626703 [ Mac10.12 ] external/wpt/html/dom/idlharness.https.html?exclude=(Document|Window|HTML.\*) [ Failure Timeout ]
 crbug.com/626703 [ Win7 ] external/wpt/content-security-policy/object-src/object-src-no-url-allowed.html [ Timeout ]
 crbug.com/626703 [ Win7 ] external/wpt/content-security-policy/plugin-types/plugintypes-nourl-allowed.html [ Timeout ]
-crbug.com/626703 [ Linux ] external/wpt/service-workers/service-worker/ready.https.window.html [ Timeout ]
-crbug.com/626703 [ Mac ] external/wpt/service-workers/service-worker/ready.https.window.html [ Timeout ]
-crbug.com/626703 [ Win ] external/wpt/service-workers/service-worker/ready.https.window.html [ Timeout ]
+crbug.com/626703 external/wpt/service-workers/service-worker/ready.https.window.html [ Timeout ]
 crbug.com/626703 [ Win7 ] external/wpt/pointerevents/pointerevent_touch-action-pan-x-css_touch.html [ Timeout ]
 crbug.com/1040874 [ Mac ] external/wpt/pointerevents/pointerevent_pointercapture_in_frame.html [ Pass Failure ]
 crbug.com/626703 [ Win7 ] external/wpt/pointerevents/pointerevent_touch-action-pan-left-css_touch.html [ Timeout ]
@@ -2804,22 +2705,14 @@
 crbug.com/626703 external/wpt/streams/readable-byte-streams/construct-byob-request.any.sharedworker.html [ Timeout ]
 crbug.com/626703 [ Mac ] external/wpt/html/infrastructure/safe-passing-of-structured-data/shared-array-buffers/window-iframe-messagechannel.https.html [ Timeout ]
 crbug.com/626703 [ Win ] external/wpt/html/infrastructure/safe-passing-of-structured-data/shared-array-buffers/window-iframe-messagechannel.https.html [ Timeout ]
-crbug.com/626703 [ Linux ] external/wpt/fetch/corb/script-resource-with-nonsniffable-types.tentative.sub.html [ Timeout ]
-crbug.com/626703 [ Mac ] external/wpt/fetch/corb/script-resource-with-nonsniffable-types.tentative.sub.html [ Timeout ]
-crbug.com/626703 [ Win ] external/wpt/fetch/corb/script-resource-with-nonsniffable-types.tentative.sub.html [ Timeout ]
+crbug.com/626703 external/wpt/fetch/corb/script-resource-with-nonsniffable-types.tentative.sub.html [ Timeout ]
 crbug.com/626703 [ Win ] external/wpt/webvtt/rendering/cues-with-video/processing-model/embedded_style_media_queries.html [ Failure ]
 crbug.com/626703 [ Win ] external/wpt/webvtt/rendering/cues-with-video/processing-model/embedded_style_media_queries_resized.html [ Failure ]
-crbug.com/626703 [ Linux ] external/wpt/html/webappapis/dynamic-markup-insertion/opening-the-input-stream/location-set-and-document-open.html [ Timeout ]
-crbug.com/626703 [ Mac ] external/wpt/html/webappapis/dynamic-markup-insertion/opening-the-input-stream/location-set-and-document-open.html [ Timeout ]
-crbug.com/626703 [ Win ] external/wpt/html/webappapis/dynamic-markup-insertion/opening-the-input-stream/location-set-and-document-open.html [ Timeout ]
+crbug.com/626703 external/wpt/html/webappapis/dynamic-markup-insertion/opening-the-input-stream/location-set-and-document-open.html [ Timeout ]
 crbug.com/626703 [ Mac ] external/wpt/preload/preload-with-type.html [ Pass Timeout ]
 crbug.com/626703 [ Mac ] external/wpt/html/rendering/non-replaced-elements/form-controls/select-sizing-001.html [ Failure ]
-crbug.com/626703 [ Linux ] external/wpt/css/css-align/baseline-rules/grid-item-input-type-number.html [ Failure ]
-crbug.com/626703 [ Mac ] external/wpt/css/css-align/baseline-rules/grid-item-input-type-number.html [ Failure ]
-crbug.com/626703 [ Win ] external/wpt/css/css-align/baseline-rules/grid-item-input-type-number.html [ Failure ]
-crbug.com/626703 [ Linux ] external/wpt/css/css-align/baseline-rules/grid-item-input-type-text.html [ Failure ]
-crbug.com/626703 [ Mac ] external/wpt/css/css-align/baseline-rules/grid-item-input-type-text.html [ Failure ]
-crbug.com/626703 [ Win ] external/wpt/css/css-align/baseline-rules/grid-item-input-type-text.html [ Failure ]
+crbug.com/626703 external/wpt/css/css-align/baseline-rules/grid-item-input-type-number.html [ Failure ]
+crbug.com/626703 external/wpt/css/css-align/baseline-rules/grid-item-input-type-text.html [ Failure ]
 crbug.com/626703 external/wpt/webaudio/the-audio-api/processing-model/feedback-delay-time.html [ Failure ]
 crbug.com/626703 external/wpt/webaudio/the-audio-api/processing-model/delay-time-clamping.html [ Failure ]
 crbug.com/626703 external/wpt/webaudio/the-audio-api/processing-model/cycle-without-delay.html [ Failure ]
@@ -2831,12 +2724,8 @@
 crbug.com/626703 [ Win10 ] external/wpt/payment-request/payment-request-hasenrolledinstrument-method.tentative.https.html [ Failure Timeout ]
 crbug.com/626703 [ Win10 ] external/wpt/css/css-paint-api/color-custom-property-animation.https.html [ Failure ]
 crbug.com/626703 [ Win ] external/wpt/web-animations/timing-model/animation-effects/phases-and-states.html [ Crash ]
-crbug.com/626703 [ Linux ] external/wpt/webvtt/rendering/cues-with-video/processing-model/snap-to-line.html [ Failure ]
-crbug.com/626703 [ Mac ] external/wpt/webvtt/rendering/cues-with-video/processing-model/snap-to-line.html [ Failure ]
-crbug.com/626703 [ Win ] external/wpt/webvtt/rendering/cues-with-video/processing-model/snap-to-line.html [ Failure ]
-crbug.com/626703 [ Linux ] external/wpt/shadow-dom/directionality-002.tentative.html [ Failure ]
-crbug.com/626703 [ Mac ] external/wpt/shadow-dom/directionality-002.tentative.html [ Failure ]
-crbug.com/626703 [ Win ] external/wpt/shadow-dom/directionality-002.tentative.html [ Failure ]
+crbug.com/626703 external/wpt/webvtt/rendering/cues-with-video/processing-model/snap-to-line.html [ Failure ]
+crbug.com/626703 external/wpt/shadow-dom/directionality-002.tentative.html [ Failure ]
 crbug.com/626703 [ Mac10.13 ] external/wpt/webaudio/the-audio-api/the-mediastreamaudiosourcenode-interface/mediastreamaudiosourcenode-routing.html [ Timeout ]
 crbug.com/626703 [ Mac10.14 ] external/wpt/webaudio/the-audio-api/the-mediastreamaudiosourcenode-interface/mediastreamaudiosourcenode-routing.html [ Timeout ]
 crbug.com/626703 [ Win7 ] external/wpt/IndexedDB/structured-clone.any.html [ Timeout ]
@@ -2853,12 +2742,8 @@
 crbug.com/1004760 [ Mac ] external/wpt/html/semantics/embedded-content/media-elements/ready-states/autoplay-hidden.optional.html [ Timeout ]
 crbug.com/626703 external/wpt/mediacapture-streams/MediaStream-MediaElement-srcObject.https.html [ Timeout ]
 crbug.com/699040 external/wpt/svg/text/reftests/text-xml-space-001.svg [ Failure ]
-crbug.com/626703 [ Linux ] external/wpt/css/css-sizing/slice-intrinsic-size.html [ Failure ]
-crbug.com/626703 [ Mac ] external/wpt/css/css-sizing/slice-intrinsic-size.html [ Failure ]
-crbug.com/626703 [ Win ] external/wpt/css/css-sizing/slice-intrinsic-size.html [ Failure ]
-crbug.com/626703 [ Linux ] external/wpt/css/css-sizing/clone-intrinsic-size.html [ Failure ]
-crbug.com/626703 [ Mac ] external/wpt/css/css-sizing/clone-intrinsic-size.html [ Failure ]
-crbug.com/626703 [ Win ] external/wpt/css/css-sizing/clone-intrinsic-size.html [ Failure ]
+crbug.com/626703 external/wpt/css/css-sizing/slice-intrinsic-size.html [ Failure ]
+crbug.com/626703 external/wpt/css/css-sizing/clone-intrinsic-size.html [ Failure ]
 crbug.com/626703 [ Mac10.12 ] external/wpt/preload/download-resources.html [ Failure Timeout ]
 crbug.com/626703 [ Mac10.13 ] external/wpt/preload/download-resources.html [ Failure Timeout ]
 crbug.com/626703 external/wpt/css/css-writing-modes/text-combine-upright-digits-001-manual.html [ Skip ]
@@ -3963,6 +3848,7 @@
 crbug.com/1045599 virtual/layout-ng-grid/external/wpt/css/css-grid/alignment/self-baseline/grid-self-baseline-005.html [ Failure ]
 crbug.com/1045599 virtual/layout-ng-grid/external/wpt/css/css-grid/alignment/self-baseline/grid-self-baseline-006.html [ Failure ]
 crbug.com/1045599 virtual/layout-ng-grid/external/wpt/css/css-grid/alignment/self-baseline/grid-self-baseline-007.html [ Failure ]
+crbug.com/1045599 virtual/layout-ng-grid/external/wpt/css/css-grid/alignment/self-baseline/grid-self-baseline-008.html [ Failure ]
 crbug.com/1045599 virtual/layout-ng-grid/external/wpt/css/css-grid/alignment/self-baseline/grid-self-baseline-changes-grid-area-size-001.html [ Failure ]
 crbug.com/1045599 virtual/layout-ng-grid/external/wpt/css/css-grid/alignment/self-baseline/grid-self-baseline-changes-grid-area-size-002.html [ Failure ]
 crbug.com/1045599 virtual/layout-ng-grid/external/wpt/css/css-grid/alignment/self-baseline/grid-self-baseline-changes-grid-area-size-003.html [ Failure ]
@@ -5430,6 +5316,9 @@
 
 # This test is not intended to pass on Plan B.
 crbug.com/740501 virtual/webrtc-wpt-plan-b/external/wpt/webrtc/RTCPeerConnection-onnegotiationneeded.html [ Pass Failure Timeout ]
+# Temporarily disable to unblock a WebRTC CL that makes more tests pass.
+crbug.com/1060083 external/wpt/webrtc/RTCPeerConnection-onnegotiationneeded.html [ Pass Failure ]
+crbug.com/1060083 external/wpt/webrtc/RTCPeerConnection-setRemoteDescription-rollback.html [ Pass Failure ]
 
 crbug.com/910979 http/tests/html/validation-bubble-oopif-clip.html [ Failure Pass ]
 
@@ -6688,6 +6577,3 @@
 crbug.com/1120330 virtual/threaded/external/wpt/feature-policy/experimental-features/vertical-scroll-disabled-scrollbar-tentative.html [ Pass Failure ]
 
 crbug.com/1119676 external/wpt/html/cross-origin-embedder-policy/reporting-to-endpoint.https.html [ Failure ]
-
-# Sheriff 2020-08-25
-crbug.com/1121429 fast/selectors/placeholder-shown-style-update.html [ Pass Crash ]

diff --git a/third_party/blink/web_tests/external/WPT_BASE_MANIFEST_8.json b/third_party/blink/web_tests/external/WPT_BASE_MANIFEST_8.json
index 15f55ce..0088a648 100644
--- a/third_party/blink/web_tests/external/WPT_BASE_MANIFEST_8.json
+++ b/third_party/blink/web_tests/external/WPT_BASE_MANIFEST_8.json

@@ -199024,10 +199024,18 @@
        "79316cb488fade6e877c690f90c74961ff944f52",
        []
       ],
+      "async-script.js": [
+       "3c0ee6d02343891b0234f31c0fb229929ae1b24b",
+       []
+      ],
       "common.js": [
        "639847abf36d636e537c081a6afd06a3a8fb7f9f",
        []
       ],
+      "defer-script.js": [
+       "8d248ee0d01402bf016255d82c2b59d337c33b45",
+       []
+      ],
       "document-policy-image.html": [
        "4e5b919bd112f044cc3ec9e57afe05ae20f22ece",
        []
@@ -199056,11 +199064,23 @@
        "73ca820915bbdccdf4fd2d3960c795f1cea8e181",
        []
       ],
+      "parser-blocking-script.js": [
+       "c61efee8a0a15801d474fd8b384de01e565e37ce",
+       []
+      ],
+      "sync-script-test.js": [
+       "65c1b21e6e8274dc06679a67c79a67dc1ba756c4",
+       []
+      ],
       "video.ogv": [
        "c9ee910fc667632b17420c1f0ad4f7ad2ac7446a",
        []
       ]
      },
+     "sync-script.tentative.https.sub.html.headers": [
+      "cfe200c27b007ebb8f470c9b19a59589e68500e3",
+      []
+     ],
      "unsized-media.tentative.https.sub.html.headers": [
       "cf59933e8dd61a728ada5644a71808c36e7b0876",
       []
@@ -202034,18 +202054,10 @@
     ],
     "experimental-features": {
      "resources": {
-      "async-script.js": [
-       "3c0ee6d02343891b0234f31c0fb229929ae1b24b",
-       []
-      ],
       "common.js": [
        "c6bea8175129f158f9d2c90c5463cd54f4919a2a",
        []
       ],
-      "defer-script.js": [
-       "8d248ee0d01402bf016255d82c2b59d337c33b45",
-       []
-      ],
       "feature-policy-trust-token-redemption.html": [
        "6ae6f6fa4d4684af4b839658ed295d7cfec976cd",
        []
@@ -202062,14 +202074,6 @@
        "fd3da53a29c3e7f55f950611d34694867b0ff0a4",
        []
       ],
-      "parser-blocking-script.js": [
-       "c61efee8a0a15801d474fd8b384de01e565e37ce",
-       []
-      ],
-      "sync-script-test.js": [
-       "65c1b21e6e8274dc06679a67c79a67dc1ba756c4",
-       []
-      ],
       "vertical-scroll-scrollable-content.html": [
        "9f78ea4bc2975abf6d37a24952df48e6dc75400f",
        []
@@ -202099,10 +202103,6 @@
        []
       ]
      },
-     "sync-script.tentative.https.sub.html.headers": [
-      "b468c8b1822d57cbf8c78523397a43813cefe51c",
-      []
-     ],
      "vertical-scroll-main-frame-manual.tentative.html.headers": [
       "44072fce5640c79fcbd804550bfce44dbad37738",
       []
@@ -204297,10 +204297,6 @@
       "c4f1bd6e43f5a71375d1c4d6a236fa73e5d77c9a",
       []
      ],
-     "document-fullscreen-enabled-expected.txt": [
-      "7ac8b232021eab62f5c44d1a3719d3f2b510e091",
-      []
-     ],
      "element-ready-check-not-allowed-manual-expected.txt": [
       "fec32b83f3a72686bd580798b07e348c5e047025",
       []
@@ -208174,6 +208170,10 @@
        "748fd996cfbb5dceec670033308fa68502d70cb0",
        []
       ],
+      "javascript-url-same-origin.https.html": [
+       "be2e59312b71ba72bb4636867b90b9557f6b5165",
+       []
+      ],
       "popup-coop-by-sw.js": [
        "7b16e3162713de8132886178c5c8be106e7ec712",
        []
@@ -295435,6 +295435,13 @@
        {}
       ]
      ],
+     "sync-script.tentative.https.sub.html": [
+      "a199a4ed3f9a80c723ebf67551893429d15e86a9",
+      [
+       null,
+       {}
+      ]
+     ],
      "unsized-media.tentative.https.sub.html": [
       "d7bb72524902cbd519d892b8206569d7607a120b",
       [
@@ -312473,13 +312480,6 @@
        {}
       ]
      ],
-     "sync-script.tentative.https.sub.html": [
-      "94f0dcf13fcf9453d8460bbd2102479974ac9c6e",
-      [
-       null,
-       {}
-      ]
-     ],
      "trust-token-redemption-default-feature-policy.tentative.https.sub.html": [
       "d88048953ea3f1d26dee502ef331bc3f07ec0152",
       [
@@ -316962,7 +316962,7 @@
       ]
      ],
      "document-fullscreen-enabled.html": [
-      "8c7057b430cc5125e5905116cc3d2fa57b452e3b",
+      "40430d7bbfbaf9425f45965819ef8b2407cb2c9c",
       [
        null,
        {}
@@ -337850,6 +337850,15 @@
        }
       ]
      ],
+     "javascript-url.https.html": [
+      "a10c939ed50cce5426e8e8127c4c6e2e86dfa381",
+      [
+       null,
+       {
+        "timeout": "long"
+       }
+      ]
+     ],
      "no-https.html": [
       "db15d5c676efb6f5761dec52ad56580fdfc1acbf",
       [

diff --git a/third_party/blink/web_tests/external/wpt/css/css-grid/alignment/self-baseline/grid-self-baseline-008-ref.html b/third_party/blink/web_tests/external/wpt/css/css-grid/alignment/self-baseline/grid-self-baseline-008-ref.html
new file mode 100644
index 0000000..7876656
--- /dev/null
+++ b/third_party/blink/web_tests/external/wpt/css/css-grid/alignment/self-baseline/grid-self-baseline-008-ref.html

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<style>
+div {
+  float: left;
+  width: 200px;
+  height: 200px;
+  background: green;
+}
+</style>
+<div></div>
+<div style="margin-top: 100px"></div>

diff --git a/third_party/blink/web_tests/external/wpt/css/css-grid/alignment/self-baseline/grid-self-baseline-008.html b/third_party/blink/web_tests/external/wpt/css/css-grid/alignment/self-baseline/grid-self-baseline-008.html
new file mode 100644
index 0000000..5398b7e
--- /dev/null
+++ b/third_party/blink/web_tests/external/wpt/css/css-grid/alignment/self-baseline/grid-self-baseline-008.html

@@ -0,0 +1,39 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>CSS Grid Layout Test: baseline context and self alignment</title>
+<link rel="author" title="Oriol Brufau" href="mailto:obrufau@igalia.com" />
+<link rel="help" href="https://drafts.csswg.org/css-grid/#alignment">
+<link rel="help" href="https://drafts.csswg.org/css-align-3/#baseline-align-self">
+<link rel="help" href="https://drafts.csswg.org/css-align-3/#align-by-baseline">
+<link rel="help" href="https://drafts.csswg.org/css-align-3/#align-items-property">
+<link rel="help" href="https://drafts.csswg.org/css-align-3/#align-self-property">
+<link rel="help" href="https://bugs.chromium.org/p/chromium/issues/detail?id=1121761">
+<link rel="match" href="grid-self-baseline-008-ref.html">
+<link rel="stylesheet" href="/css/support/alignment.css">
+<meta name="assert" content="Test baseline alignment with percentage track sizing functions and grid items being or containing replaced elements with aspect ratio and percentage sizes." />
+<style>
+.grid {
+  display: grid;
+  width: 400px;
+  grid-template-columns: 25% 25% 25% 25%;
+  line-height: 0;
+}
+.percent {
+  width: 100%;
+}
+canvas {
+  background: green;
+}
+</style>
+<div class="grid alignItemsBaseline">
+  <canvas width="100" height="200"></canvas>
+  <canvas width="200" height="400" class="percent"></canvas>
+  <div>
+    <canvas width="100" height="100" class="percent"></canvas>
+    <canvas width="100" height="100" class="percent"></canvas>
+  </div>
+  <div class="percent">
+    <canvas width="100" height="100" class="percent"></canvas>
+    <canvas width="100" height="100" class="percent"></canvas>
+  </div>
+</div>

diff --git a/third_party/blink/web_tests/external/wpt/fullscreen/api/document-fullscreen-enabled-expected.txt b/third_party/blink/web_tests/external/wpt/fullscreen/api/document-fullscreen-enabled-expected.txt
deleted file mode 100644
index 7ac8b232..0000000
--- a/third_party/blink/web_tests/external/wpt/fullscreen/api/document-fullscreen-enabled-expected.txt
+++ /dev/null

@@ -1,4 +0,0 @@
-This is a testharness.js-based test.
-FAIL Document#fullscreenEnabled assert_false: iframe without allowfullscreen expected false got true
-Harness: the test ran to completion.
-

diff --git a/third_party/blink/web_tests/external/wpt/fullscreen/api/document-fullscreen-enabled.html b/third_party/blink/web_tests/external/wpt/fullscreen/api/document-fullscreen-enabled.html
index 8c7057b4..40430d7 100644
--- a/third_party/blink/web_tests/external/wpt/fullscreen/api/document-fullscreen-enabled.html
+++ b/third_party/blink/web_tests/external/wpt/fullscreen/api/document-fullscreen-enabled.html

@@ -4,14 +4,14 @@
 <script src="/resources/testharnessreport.js"></script>
 <div id="log"></div>
 <iframe></iframe>
-<iframe allowfullscreen></iframe>
 <script>
 test(function()
 {
     assert_true(document.fullscreenEnabled, "top-level document");
-
-    var iframes = document.getElementsByTagName("iframe");
-    assert_false(iframes[0].contentDocument.fullscreenEnabled, "iframe without allowfullscreen");
-    assert_true(iframes[1].contentDocument.fullscreenEnabled, "iframe with allowfullscreen");
+    const iframe = document.querySelector("iframe");
+    assert_true(iframe.contentDocument.fullscreenEnabled, "same-origin iframe");
 });
+
+// The cross-origin iframe case is tested in
+// /html/semantics/embedded-content/the-iframe-element/iframe-allowfullscreen.html
 </script>

diff --git a/third_party/blink/web_tests/external/wpt/html/cross-origin-opener-policy/javascript-url.https.html b/third_party/blink/web_tests/external/wpt/html/cross-origin-opener-policy/javascript-url.https.html
new file mode 100644
index 0000000..a10c939
--- /dev/null
+++ b/third_party/blink/web_tests/external/wpt/html/cross-origin-opener-policy/javascript-url.https.html

@@ -0,0 +1,262 @@
+<!DOCTYPE html>
+<title>Cross-Origin-Opener-Policy and a "javascript:" URL popup</title>
+<meta charset="utf-8">
+<meta name="timeout" content="long">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="/common/get-host-info.sub.js"></script>
+<script src="/common/utils.js"></script>
+
+<p>According to HTML's navigate algorithm, requests to <code>javascript:</code>
+URLs should inherit the cross-origin opener policy of the active document. To
+observe this, each subtest uses the following procedure.</p>
+
+<ol>
+  <li>create popup with a given COOP (the <code>parentCOOP</code>)</li>
+  <li>navigate the popup to a <code>javascript:</code> URL (the new document is
+  expected to inherit the <code>parentCOOP</code>)</li>
+  <li>from the popup, create a second popup window with a given COOP (the
+  <code>childCOOP</code>)</li>
+</ol>
+
+<p>Both popup windows inspect state and report back to the test context using
+BroadcastChannels.</p>
+
+<pre>
+    .---- test ----.
+    | open(https:) |
+    |  parentCOOP  |   .----- subject -------.
+    |      '---------> | --------.           |
+    |              |   |         v           |
+    |              |   | assign(javascript:) |
+    |              |   |  (COOP under test)  |
+    |              |   |         |           |
+    |              |   |    open(https:)     |
+    |              |   |     childCOOP       |    .- child -.
+    |              |   |         '--------------> |         |
+    |              |   '---------------------'    '---------'
+    |              |             |                     |
+    |  validate    | <--status---+---------------------'
+    '--------------'
+</pre>
+
+<script>
+'use strict';
+
+function run(t, parentCOOP, childCOOP, origin, name) {
+  const bc = new BroadcastChannel(name);
+  const childURL = encodeURIComponent(`${origin}/html/cross-origin-opener-policy/resources/coop-coep.py?coop=${childCOOP}&coep=&channel=${name}`);
+
+  open(
+    `/html/cross-origin-opener-policy/resources/javascript-url-same-origin.https.html` +
+      `?pipe=header(cross-origin-opener-policy,${parentCOOP})` +
+      `&childURL=${childURL}` +
+      `&childName=${name}`
+  );
+
+  t.add_cleanup(() => {
+    bc.postMessage('close');
+  });
+
+  return new Promise((resolve) => {
+    bc.addEventListener('message', ({data}) => {
+      resolve(data);
+    }, {once: true});
+  }).then(({name: childName, opener: childOpener}) => {
+    return new Promise((resolve) => {
+      bc.postMessage('inspectChild');
+
+      bc.addEventListener('message', function handle({data}) {
+        if (typeof data !== 'object' || !('childClosed' in data)) { return; }
+
+        bc.removeEventListener('message', handle);
+
+        resolve({
+          childName,
+          childOpener,
+          childClosed: data.childClosed
+        });
+      });
+    });
+  });
+}
+const { HTTPS_ORIGIN, HTTPS_REMOTE_ORIGIN } = get_host_info();
+
+function assert_isolated(results) {
+  assert_equals(results.childName, '', 'child name');
+  assert_false(results.childOpener, 'child opener');
+  // The test subject's reference to the  "child" window must report "closed"
+  // when COOP enforces isolation because the document initially created during
+  // the window open steps must be discarded when a new document object is
+  // created at the end of the navigation.
+  assert_true(results.childClosed, 'child closed');
+}
+
+function assert_not_isolated(results, expectedName) {
+  assert_equals(results.childName, expectedName, 'child name');
+  assert_true(results.childOpener, 'child opener');
+  assert_false(results.childClosed, 'child closed');
+}
+
+async_test((t) => {
+  const name = token();
+  run(t, 'unsafe-none', 'unsafe-none', HTTPS_ORIGIN, name)
+    .then((results) => {
+      assert_not_isolated(results, name);
+    })
+    .then(t.step_func_done(), t.step_func((e) => { throw e; }));
+}, 'navigation: same origin; parentCOOP: unsafe-none; childCOOP: unsafe-none');
+
+async_test((t) => {
+  const name = token();
+  run(t, 'unsafe-none', 'unsafe-none', HTTPS_REMOTE_ORIGIN, name)
+    .then((results) => {
+      assert_not_isolated(results, name);
+    })
+    .then(t.step_func_done(), t.step_func((e) => { throw e; }));
+}, 'navigation: cross origin; parentCOOP: unsafe-none; childCOOP: unsafe-none');
+
+async_test((t) => {
+  const name = token();
+  run(t, 'unsafe-none', 'same-origin-allow-popups', HTTPS_ORIGIN, name)
+    .then((results) => {
+      assert_isolated(results);
+    })
+    .then(t.step_func_done(), t.step_func((e) => { throw e; }));
+}, 'navigation: same origin; parentCOOP: unsafe-none; childCOOP: same-origin-allow-popups');
+
+async_test((t) => {
+  const name = token();
+  run(t, 'unsafe-none', 'same-origin-allow-popups', HTTPS_REMOTE_ORIGIN, name)
+    .then((results) => {
+      assert_isolated(results);
+    })
+    .then(t.step_func_done(), t.step_func((e) => { throw e; }));
+}, 'navigation: cross origin; parentCOOP: unsafe-none; childCOOP: same-origin-allow-popups');
+
+async_test((t) => {
+  const name = token();
+  run(t, 'unsafe-none', 'same-origin', HTTPS_ORIGIN, name)
+    .then((results) => {
+      assert_isolated(results);
+    })
+    .then(t.step_func_done(), t.step_func((e) => { throw e; }));
+}, 'navigation: same origin; parentCOOP: unsafe-none; childCOOP: same-origin');
+
+async_test((t) => {
+  const name = token();
+  run(t, 'unsafe-none', 'same-origin', HTTPS_REMOTE_ORIGIN, name)
+    .then((results) => {
+      assert_isolated(results);
+    })
+    .then(t.step_func_done(), t.step_func((e) => { throw e; }));
+}, 'navigation: cross origin; parentCOOP: unsafe-none; childCOOP: same-origin');
+
+async_test((t) => {
+  const name = token();
+  run(t, 'same-origin-allow-popups', 'unsafe-none', HTTPS_ORIGIN, name)
+    .then((results) => {
+      assert_not_isolated(results, name);
+    })
+    .then(t.step_func_done(), t.step_func((e) => { throw e; }));
+}, 'navigation: same origin; parentCOOP: same-origin-allow-popups; childCOOP: unsafe-none');
+
+async_test((t) => {
+  const name = token();
+  run(t, 'same-origin-allow-popups', 'unsafe-none', HTTPS_REMOTE_ORIGIN, name)
+    .then((results) => {
+      assert_not_isolated(results, name);
+    })
+    .then(t.step_func_done(), t.step_func((e) => { throw e; }));
+}, 'navigation: cross origin; parentCOOP: same-origin-allow-popups; childCOOP: unsafe-none');
+
+async_test((t) => {
+  const name = token();
+  run(t, 'same-origin-allow-popups', 'same-origin-allow-popups', HTTPS_ORIGIN, name)
+    .then((results) => {
+      assert_not_isolated(results, name);
+    })
+    .then(t.step_func_done(), t.step_func((e) => { throw e; }));
+}, 'navigation: same origin; parentCOOP: same-origin-allow-popups; childCOOP: same-origin-allow-popups');
+
+async_test((t) => {
+  const name = token();
+  run(t, 'same-origin-allow-popups', 'same-origin-allow-popups', HTTPS_REMOTE_ORIGIN, name)
+    .then((results) => {
+      assert_isolated(results);
+    })
+    .then(t.step_func_done(), t.step_func((e) => { throw e; }));
+}, 'navigation: cross origin; parentCOOP: same-origin-allow-popups; childCOOP: same-origin-allow-popups');
+
+async_test((t) => {
+  const name = token();
+  run(t, 'same-origin-allow-popups', 'same-origin', HTTPS_ORIGIN, name)
+    .then((results) => {
+      assert_isolated(results);
+    })
+    .then(t.step_func_done(), t.step_func((e) => { throw e; }));
+}, 'navigation: same origin; parentCOOP: same-origin-allow-popups; childCOOP: same-origin');
+
+async_test((t) => {
+  const name = token();
+  run(t, 'same-origin-allow-popups', 'same-origin', HTTPS_REMOTE_ORIGIN, name)
+    .then((results) => {
+      assert_isolated(results);
+    })
+    .then(t.step_func_done(), t.step_func((e) => { throw e; }));
+}, 'navigation: cross origin; parentCOOP: same-origin-allow-popups; childCOOP: same-origin');
+
+async_test((t) => {
+  const name = token();
+  run(t, 'same-origin', 'unsafe-none', HTTPS_ORIGIN, name)
+    .then((results) => {
+      assert_isolated(results);
+    })
+    .then(t.step_func_done(), t.step_func((e) => { throw e; }));
+}, 'navigation: same origin; parentCOOP: same-origin; childCOOP: unsafe-none');
+
+async_test((t) => {
+  const name = token();
+  run(t, 'same-origin', 'unsafe-none', HTTPS_REMOTE_ORIGIN, name)
+    .then((results) => {
+      assert_isolated(results);
+    })
+    .then(t.step_func_done(), t.step_func((e) => { throw e; }));
+}, 'navigation: cross origin; parentCOOP: same-origin; childCOOP: unsafe-none');
+
+async_test((t) => {
+  const name = token();
+  run(t, 'same-origin', 'same-origin-allow-popups', HTTPS_ORIGIN, name)
+    .then((results) => {
+      assert_isolated(results);
+    })
+    .then(t.step_func_done(), t.step_func((e) => { throw e; }));
+}, 'navigation: same origin; parentCOOP: same-origin; childCOOP: same-origin-allow-popups');
+
+async_test((t) => {
+  const name = token();
+  run(t, 'same-origin', 'same-origin-allow-popups', HTTPS_REMOTE_ORIGIN, name)
+    .then((results) => {
+      assert_isolated(results);
+    })
+    .then(t.step_func_done(), t.step_func((e) => { throw e; }));
+}, 'navigation: cross origin; parentCOOP: same-origin; childCOOP: same-origin-allow-popups');
+
+async_test((t) => {
+  const name = token();
+  run(t, 'same-origin', 'same-origin', HTTPS_ORIGIN, name)
+    .then((results) => {
+      assert_not_isolated(results, name);
+    })
+    .then(t.step_func_done(), t.step_func((e) => { throw e; }));
+}, 'navigation: same origin; parentCOOP: same-origin; childCOOP: same-origin');
+
+async_test((t) => {
+  const name = token();
+  run(t, 'same-origin', 'same-origin', HTTPS_REMOTE_ORIGIN, name)
+    .then((results) => {
+      assert_isolated(results);
+    })
+    .then(t.step_func_done(), t.step_func((e) => { throw e; }));
+}, 'navigation: cross origin; parentCOOP: same-origin; childCOOP: same-origin');
+</script>

diff --git a/third_party/blink/web_tests/external/wpt/html/cross-origin-opener-policy/resources/javascript-url-same-origin.https.html b/third_party/blink/web_tests/external/wpt/html/cross-origin-opener-policy/resources/javascript-url-same-origin.https.html
new file mode 100644
index 0000000..be2e5931
--- /dev/null
+++ b/third_party/blink/web_tests/external/wpt/html/cross-origin-opener-policy/resources/javascript-url-same-origin.https.html

@@ -0,0 +1,33 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<script src="/common/get-host-info.sub.js"></script>
+<body>
+<script>
+'use strict';
+const params = new URLSearchParams(location.search);
+const childURL = JSON.stringify(encodeURIComponent(params.get('childURL')));
+const childName = JSON.stringify(params.get('childName'));
+location.assign(`javascript:\`<body><script>
+const child = window.open(${childURL}, ${childName});
+const bc = new BroadcastChannel(${childName});
+
+bc.addEventListener('message', ({data}) => {
+  if (data === 'close') {
+    close();
+    return;
+  }
+  if (data === 'inspectChild') {
+    const iframe = document.createElement('iframe');
+    iframe.onload = () => {
+      const payload = {
+        childClosed: child.closed
+      };
+      iframe.contentWindow.postMessage(payload, '*');
+    };
+    iframe.src = '${get_host_info().HTTPS_ORIGIN}/html/cross-origin-opener-policy/resources/postback.html?channel=${params.get('childName')}';
+    document.body.appendChild(iframe);
+  }
+});
+<\/script></body>\``);
+</script>
+</body>

diff --git a/third_party/blink/web_tests/flag-specific/composite-after-paint/paint/invalidation/svg/composited-svg-expected.txt b/third_party/blink/web_tests/flag-specific/composite-after-paint/paint/invalidation/svg/composited-svg-expected.txt
new file mode 100644
index 0000000..a549b1d7
--- /dev/null
+++ b/third_party/blink/web_tests/flag-specific/composite-after-paint/paint/invalidation/svg/composited-svg-expected.txt

@@ -0,0 +1,39 @@
+{
+  "layers": [
+    {
+      "name": "Scrolling background of LayoutView #document",
+      "bounds": [800, 600],
+      "contentsOpaque": true,
+      "backgroundColor": "#FFFFFF"
+    },
+    {
+      "name": "LayoutSVGRect rect id='rect'",
+      "position": [10, 10],
+      "bounds": [100, 100],
+      "contentsOpaque": true,
+      "transform": 2
+    }
+  ],
+  "transforms": [
+    {
+      "id": 1,
+      "transform": [
+        [1, 0, 0, 0],
+        [0, 1, 0, 0],
+        [0, 0, 1, 0],
+        [8, 8, 0, 1]
+      ]
+    },
+    {
+      "id": 2,
+      "parent": 1,
+      "transform": [
+        [1, 0, 0, 0],
+        [0, 1, 0, 0],
+        [0, 0, 1, 0],
+        [0, 50, 0, 1]
+      ]
+    }
+  ]
+}
+

diff --git a/third_party/blink/web_tests/inspector-protocol/debugger/resources/xslt.xml b/third_party/blink/web_tests/inspector-protocol/debugger/resources/xslt.xml
new file mode 100644
index 0000000..e943c372
--- /dev/null
+++ b/third_party/blink/web_tests/inspector-protocol/debugger/resources/xslt.xml

@@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?xml-stylesheet type="text/xsl" href="xslt.xslt"?>
+<TEST/>

diff --git a/third_party/blink/web_tests/inspector-protocol/debugger/resources/xslt.xslt b/third_party/blink/web_tests/inspector-protocol/debugger/resources/xslt.xslt
new file mode 100644
index 0000000..685886e
--- /dev/null
+++ b/third_party/blink/web_tests/inspector-protocol/debugger/resources/xslt.xslt

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
+    <xsl:output method="html" encoding="iso8859-1"/>
+    <xsl:template match="TEST">
+        <body>
+        <script>
+          debugger;
+        </script>
+        </body>
+    </xsl:template>
+</xsl:stylesheet>

diff --git a/third_party/blink/web_tests/inspector-protocol/debugger/unpause-after-xslt-commit-expected.txt b/third_party/blink/web_tests/inspector-protocol/debugger/unpause-after-xslt-commit-expected.txt
new file mode 100644
index 0000000..d2e78252
--- /dev/null
+++ b/third_party/blink/web_tests/inspector-protocol/debugger/unpause-after-xslt-commit-expected.txt

@@ -0,0 +1,2 @@
+Test that debugger breakpoints still work after reloading an xslt document
+

diff --git a/third_party/blink/web_tests/inspector-protocol/debugger/unpause-after-xslt-commit.js b/third_party/blink/web_tests/inspector-protocol/debugger/unpause-after-xslt-commit.js
new file mode 100644
index 0000000..bc421ed4
--- /dev/null
+++ b/third_party/blink/web_tests/inspector-protocol/debugger/unpause-after-xslt-commit.js

@@ -0,0 +1,13 @@
+(async function(testRunner) {
+  var {page, session, dp} = await testRunner.startURL('resources/xslt.xml',
+      'Test that debugger breakpoints still work after reloading an xslt document');
+
+  await dp.Debugger.enable();
+  await dp.Page.enable();
+  await dp.Runtime.enable();
+  await Promise.all([
+    dp.Page.reload(),
+    dp.Debugger.oncePaused(),
+  ]);
+  testRunner.completeTest();
+})

diff --git a/third_party/blink/web_tests/paint/invalidation/svg/composited-svg-expected.html b/third_party/blink/web_tests/paint/invalidation/svg/composited-svg-expected.html
new file mode 100644
index 0000000..09f7e15
--- /dev/null
+++ b/third_party/blink/web_tests/paint/invalidation/svg/composited-svg-expected.html

@@ -0,0 +1,4 @@
+<!DOCTYPE html>
+<svg width="200" height="200">
+  <rect id="rect" x="10" y="60" width="100" height="100" fill="green">
+</svg>

diff --git a/third_party/blink/web_tests/paint/invalidation/svg/composited-svg-expected.txt b/third_party/blink/web_tests/paint/invalidation/svg/composited-svg-expected.txt
new file mode 100644
index 0000000..ae490a6e
--- /dev/null
+++ b/third_party/blink/web_tests/paint/invalidation/svg/composited-svg-expected.txt

@@ -0,0 +1,38 @@
+{
+  "layers": [
+    {
+      "name": "Scrolling Contents Layer",
+      "bounds": [800, 600],
+      "contentsOpaque": true,
+      "backgroundColor": "#FFFFFF"
+    },
+    {
+      "name": "LayoutSVGRect rect id='rect'",
+      "position": [10, 10],
+      "bounds": [100, 100],
+      "transform": 2
+    }
+  ],
+  "transforms": [
+    {
+      "id": 1,
+      "transform": [
+        [1, 0, 0, 0],
+        [0, 1, 0, 0],
+        [0, 0, 1, 0],
+        [8, 8, 0, 1]
+      ]
+    },
+    {
+      "id": 2,
+      "parent": 1,
+      "transform": [
+        [1, 0, 0, 0],
+        [0, 1, 0, 0],
+        [0, 0, 1, 0],
+        [0, 50, 0, 1]
+      ]
+    }
+  ]
+}
+

diff --git a/third_party/blink/web_tests/paint/invalidation/svg/composited-svg.html b/third_party/blink/web_tests/paint/invalidation/svg/composited-svg.html
new file mode 100644
index 0000000..9bc191c
--- /dev/null
+++ b/third_party/blink/web_tests/paint/invalidation/svg/composited-svg.html

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<script src="../resources/text-based-repaint.js"></script>
+<script>
+onload = runRepaintAndPixelTest;
+function repaintTest() {
+  // This should not invalidate.
+  rect.style.transform = "translateY(50px)";
+}
+</script>
+<svg width="200" height="200">
+  <rect id="rect" x="10" y="10" width="100" height="100" fill="green" style="will-change: transform">
+</svg>

diff --git a/third_party/blink/web_tests/paint/invalidation/svg/resize-svg-invalidate-children-2-expected.txt b/third_party/blink/web_tests/paint/invalidation/svg/resize-svg-invalidate-children-2-expected.txt
index 23a4878..75475618 100644
--- a/third_party/blink/web_tests/paint/invalidation/svg/resize-svg-invalidate-children-2-expected.txt
+++ b/third_party/blink/web_tests/paint/invalidation/svg/resize-svg-invalidate-children-2-expected.txt

@@ -8,11 +8,8 @@
     },
     {
       "name": "LayoutSVGRoot svg",
-      "bounds": [600, 400],
-      "invalidations": [
-        [50, 0, 500, 400],
-        [0, 120, 200, 160]
-      ],
+      "position": [50, 0],
+      "bounds": [500, 400],
       "transform": 1
     }
   ],

diff --git a/third_party/libaom/README.chromium b/third_party/libaom/README.chromium
index 1d03e32..ece9e7ea 100644
--- a/third_party/libaom/README.chromium
+++ b/third_party/libaom/README.chromium

@@ -2,9 +2,9 @@
 Short Name: libaom
 URL: https://aomedia.googlesource.com/aom/
 Version: 0
-Date: Tuesday July 21 2020
+Date: Wednesday August 19 2020
 Branch: master
-Commit: 4dcbd921c3a686185c705eeccb154da52858d23b
+Commit: e2219b84bc9d723e26ae6618beecad045612017e
 License: BSD
 License File: source/libaom/LICENSE
 Security Critical: yes

diff --git a/third_party/libaom/libaom_srcs.gni b/third_party/libaom/libaom_srcs.gni
index 137e467..f9cb443 100644
--- a/third_party/libaom/libaom_srcs.gni
+++ b/third_party/libaom/libaom_srcs.gni

@@ -225,6 +225,7 @@
   "//third_party/libaom/source/libaom/av1/encoder/x86/encodetxb_sse2.c",
   "//third_party/libaom/source/libaom/av1/encoder/x86/highbd_block_error_intrin_sse2.c",
   "//third_party/libaom/source/libaom/av1/encoder/x86/temporal_filter_sse2.c",
+  "//third_party/libaom/source/libaom/av1/encoder/x86/highbd_temporal_filter_sse2.c",
   "//third_party/libaom/source/libaom/av1/encoder/x86/wedge_utils_sse2.c",
 ]
 

diff --git a/third_party/libaom/source/config/config/aom_version.h b/third_party/libaom/source/config/config/aom_version.h
index 4102822a..8b7645b 100644
--- a/third_party/libaom/source/config/config/aom_version.h
+++ b/third_party/libaom/source/config/config/aom_version.h

@@ -12,8 +12,8 @@
 #define VERSION_MAJOR 2
 #define VERSION_MINOR 0
 #define VERSION_PATCH 0
-#define VERSION_EXTRA "636-g4dcbd921c"
+#define VERSION_EXTRA "747-ge2219b84b"
 #define VERSION_PACKED \
   ((VERSION_MAJOR << 16) | (VERSION_MINOR << 8) | (VERSION_PATCH))
-#define VERSION_STRING_NOSP "2.0.0-636-g4dcbd921c"
-#define VERSION_STRING " 2.0.0-636-g4dcbd921c"
+#define VERSION_STRING_NOSP "2.0.0-747-ge2219b84b"
+#define VERSION_STRING " 2.0.0-747-ge2219b84b"

diff --git a/third_party/libaom/source/config/ios/arm-neon/config/aom_config.asm b/third_party/libaom/source/config/ios/arm-neon/config/aom_config.asm
index c72fccf..137f0909 100644
--- a/third_party/libaom/source/config/ios/arm-neon/config/aom_config.asm
+++ b/third_party/libaom/source/config/ios/arm-neon/config/aom_config.asm

@@ -43,6 +43,7 @@
 CONFIG_MULTITHREAD equ 1
 CONFIG_NN_V2 equ 0
 CONFIG_NORMAL_TILE_MODE equ 1
+CONFIG_OPTICAL_FLOW_API equ 0
 CONFIG_OS_SUPPORT equ 1
 CONFIG_PIC equ 0
 CONFIG_RD_DEBUG equ 0

diff --git a/third_party/libaom/source/config/ios/arm-neon/config/aom_config.h b/third_party/libaom/source/config/ios/arm-neon/config/aom_config.h
index c6d0bc38..927b683 100644
--- a/third_party/libaom/source/config/ios/arm-neon/config/aom_config.h
+++ b/third_party/libaom/source/config/ios/arm-neon/config/aom_config.h

@@ -45,6 +45,7 @@
 #define CONFIG_MULTITHREAD 1
 #define CONFIG_NN_V2 0
 #define CONFIG_NORMAL_TILE_MODE 1
+#define CONFIG_OPTICAL_FLOW_API 0
 #define CONFIG_OS_SUPPORT 1
 #define CONFIG_PIC 0
 #define CONFIG_RD_DEBUG 0

diff --git a/third_party/libaom/source/config/ios/arm-neon/config/aom_dsp_rtcd.h b/third_party/libaom/source/config/ios/arm-neon/config/aom_dsp_rtcd.h
index 0b7aca7..127d985 100644
--- a/third_party/libaom/source/config/ios/arm-neon/config/aom_dsp_rtcd.h
+++ b/third_party/libaom/source/config/ios/arm-neon/config/aom_dsp_rtcd.h

@@ -8789,6 +8789,292 @@
                             uint32_t* sad_array);
 #define aom_highbd_sad8x8x4d aom_highbd_sad8x8x4d_c
 
+unsigned int aom_highbd_sad_skip_128x128_c(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride);
+#define aom_highbd_sad_skip_128x128 aom_highbd_sad_skip_128x128_c
+
+void aom_highbd_sad_skip_128x128x4d_c(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* const ref_ptr[],
+                                      int ref_stride,
+                                      uint32_t* sad_array);
+#define aom_highbd_sad_skip_128x128x4d aom_highbd_sad_skip_128x128x4d_c
+
+unsigned int aom_highbd_sad_skip_128x64_c(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride);
+#define aom_highbd_sad_skip_128x64 aom_highbd_sad_skip_128x64_c
+
+void aom_highbd_sad_skip_128x64x4d_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* const ref_ptr[],
+                                     int ref_stride,
+                                     uint32_t* sad_array);
+#define aom_highbd_sad_skip_128x64x4d aom_highbd_sad_skip_128x64x4d_c
+
+unsigned int aom_highbd_sad_skip_16x16_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_16x16 aom_highbd_sad_skip_16x16_c
+
+void aom_highbd_sad_skip_16x16x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_16x16x4d aom_highbd_sad_skip_16x16x4d_c
+
+unsigned int aom_highbd_sad_skip_16x32_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_16x32 aom_highbd_sad_skip_16x32_c
+
+void aom_highbd_sad_skip_16x32x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_16x32x4d aom_highbd_sad_skip_16x32x4d_c
+
+unsigned int aom_highbd_sad_skip_16x4_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_16x4 aom_highbd_sad_skip_16x4_c
+
+void aom_highbd_sad_skip_16x4x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_16x4x4d aom_highbd_sad_skip_16x4x4d_c
+
+unsigned int aom_highbd_sad_skip_16x64_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_16x64 aom_highbd_sad_skip_16x64_c
+
+void aom_highbd_sad_skip_16x64x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_16x64x4d aom_highbd_sad_skip_16x64x4d_c
+
+unsigned int aom_highbd_sad_skip_16x8_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_16x8 aom_highbd_sad_skip_16x8_c
+
+void aom_highbd_sad_skip_16x8x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_16x8x4d aom_highbd_sad_skip_16x8x4d_c
+
+unsigned int aom_highbd_sad_skip_32x16_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_32x16 aom_highbd_sad_skip_32x16_c
+
+void aom_highbd_sad_skip_32x16x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_32x16x4d aom_highbd_sad_skip_32x16x4d_c
+
+unsigned int aom_highbd_sad_skip_32x32_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_32x32 aom_highbd_sad_skip_32x32_c
+
+void aom_highbd_sad_skip_32x32x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_32x32x4d aom_highbd_sad_skip_32x32x4d_c
+
+unsigned int aom_highbd_sad_skip_32x64_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_32x64 aom_highbd_sad_skip_32x64_c
+
+void aom_highbd_sad_skip_32x64x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_32x64x4d aom_highbd_sad_skip_32x64x4d_c
+
+unsigned int aom_highbd_sad_skip_32x8_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_32x8 aom_highbd_sad_skip_32x8_c
+
+void aom_highbd_sad_skip_32x8x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_32x8x4d aom_highbd_sad_skip_32x8x4d_c
+
+unsigned int aom_highbd_sad_skip_4x16_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_4x16 aom_highbd_sad_skip_4x16_c
+
+void aom_highbd_sad_skip_4x16x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_4x16x4d aom_highbd_sad_skip_4x16x4d_c
+
+unsigned int aom_highbd_sad_skip_4x4_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+#define aom_highbd_sad_skip_4x4 aom_highbd_sad_skip_4x4_c
+
+void aom_highbd_sad_skip_4x4x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+#define aom_highbd_sad_skip_4x4x4d aom_highbd_sad_skip_4x4x4d_c
+
+unsigned int aom_highbd_sad_skip_4x8_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+#define aom_highbd_sad_skip_4x8 aom_highbd_sad_skip_4x8_c
+
+void aom_highbd_sad_skip_4x8x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+#define aom_highbd_sad_skip_4x8x4d aom_highbd_sad_skip_4x8x4d_c
+
+unsigned int aom_highbd_sad_skip_64x128_c(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride);
+#define aom_highbd_sad_skip_64x128 aom_highbd_sad_skip_64x128_c
+
+void aom_highbd_sad_skip_64x128x4d_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* const ref_ptr[],
+                                     int ref_stride,
+                                     uint32_t* sad_array);
+#define aom_highbd_sad_skip_64x128x4d aom_highbd_sad_skip_64x128x4d_c
+
+unsigned int aom_highbd_sad_skip_64x16_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_64x16 aom_highbd_sad_skip_64x16_c
+
+void aom_highbd_sad_skip_64x16x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_64x16x4d aom_highbd_sad_skip_64x16x4d_c
+
+unsigned int aom_highbd_sad_skip_64x32_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_64x32 aom_highbd_sad_skip_64x32_c
+
+void aom_highbd_sad_skip_64x32x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_64x32x4d aom_highbd_sad_skip_64x32x4d_c
+
+unsigned int aom_highbd_sad_skip_64x64_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_64x64 aom_highbd_sad_skip_64x64_c
+
+void aom_highbd_sad_skip_64x64x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_64x64x4d aom_highbd_sad_skip_64x64x4d_c
+
+unsigned int aom_highbd_sad_skip_8x16_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_8x16 aom_highbd_sad_skip_8x16_c
+
+void aom_highbd_sad_skip_8x16x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x16x4d aom_highbd_sad_skip_8x16x4d_c
+
+unsigned int aom_highbd_sad_skip_8x32_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_8x32 aom_highbd_sad_skip_8x32_c
+
+void aom_highbd_sad_skip_8x32x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x32x4d aom_highbd_sad_skip_8x32x4d_c
+
+unsigned int aom_highbd_sad_skip_8x4_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+#define aom_highbd_sad_skip_8x4 aom_highbd_sad_skip_8x4_c
+
+void aom_highbd_sad_skip_8x4x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x4x4d aom_highbd_sad_skip_8x4x4d_c
+
+unsigned int aom_highbd_sad_skip_8x8_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+#define aom_highbd_sad_skip_8x8 aom_highbd_sad_skip_8x8_c
+
+void aom_highbd_sad_skip_8x8x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x8x4d aom_highbd_sad_skip_8x8x4d_c
+
 void aom_highbd_smooth_h_predictor_16x16_c(uint16_t* dst,
                                            ptrdiff_t y_stride,
                                            const uint16_t* above,
@@ -11884,6 +12170,292 @@
                           int height);
 #define aom_sad8xh aom_sad8xh_c
 
+unsigned int aom_sad_skip_128x128_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride);
+#define aom_sad_skip_128x128 aom_sad_skip_128x128_c
+
+void aom_sad_skip_128x128x4d_c(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+#define aom_sad_skip_128x128x4d aom_sad_skip_128x128x4d_c
+
+unsigned int aom_sad_skip_128x64_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+#define aom_sad_skip_128x64 aom_sad_skip_128x64_c
+
+void aom_sad_skip_128x64x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+#define aom_sad_skip_128x64x4d aom_sad_skip_128x64x4d_c
+
+unsigned int aom_sad_skip_16x16_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_16x16 aom_sad_skip_16x16_c
+
+void aom_sad_skip_16x16x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_16x16x4d aom_sad_skip_16x16x4d_c
+
+unsigned int aom_sad_skip_16x32_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_16x32 aom_sad_skip_16x32_c
+
+void aom_sad_skip_16x32x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_16x32x4d aom_sad_skip_16x32x4d_c
+
+unsigned int aom_sad_skip_16x4_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_16x4 aom_sad_skip_16x4_c
+
+void aom_sad_skip_16x4x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_16x4x4d aom_sad_skip_16x4x4d_c
+
+unsigned int aom_sad_skip_16x64_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_16x64 aom_sad_skip_16x64_c
+
+void aom_sad_skip_16x64x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_16x64x4d aom_sad_skip_16x64x4d_c
+
+unsigned int aom_sad_skip_16x8_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_16x8 aom_sad_skip_16x8_c
+
+void aom_sad_skip_16x8x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_16x8x4d aom_sad_skip_16x8x4d_c
+
+unsigned int aom_sad_skip_32x16_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_32x16 aom_sad_skip_32x16_c
+
+void aom_sad_skip_32x16x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_32x16x4d aom_sad_skip_32x16x4d_c
+
+unsigned int aom_sad_skip_32x32_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_32x32 aom_sad_skip_32x32_c
+
+void aom_sad_skip_32x32x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_32x32x4d aom_sad_skip_32x32x4d_c
+
+unsigned int aom_sad_skip_32x64_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_32x64 aom_sad_skip_32x64_c
+
+void aom_sad_skip_32x64x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_32x64x4d aom_sad_skip_32x64x4d_c
+
+unsigned int aom_sad_skip_32x8_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_32x8 aom_sad_skip_32x8_c
+
+void aom_sad_skip_32x8x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_32x8x4d aom_sad_skip_32x8x4d_c
+
+unsigned int aom_sad_skip_4x16_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_4x16 aom_sad_skip_4x16_c
+
+void aom_sad_skip_4x16x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_4x16x4d aom_sad_skip_4x16x4d_c
+
+unsigned int aom_sad_skip_4x4_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+#define aom_sad_skip_4x4 aom_sad_skip_4x4_c
+
+void aom_sad_skip_4x4x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+#define aom_sad_skip_4x4x4d aom_sad_skip_4x4x4d_c
+
+unsigned int aom_sad_skip_4x8_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+#define aom_sad_skip_4x8 aom_sad_skip_4x8_c
+
+void aom_sad_skip_4x8x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+#define aom_sad_skip_4x8x4d aom_sad_skip_4x8x4d_c
+
+unsigned int aom_sad_skip_64x128_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+#define aom_sad_skip_64x128 aom_sad_skip_64x128_c
+
+void aom_sad_skip_64x128x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+#define aom_sad_skip_64x128x4d aom_sad_skip_64x128x4d_c
+
+unsigned int aom_sad_skip_64x16_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_64x16 aom_sad_skip_64x16_c
+
+void aom_sad_skip_64x16x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_64x16x4d aom_sad_skip_64x16x4d_c
+
+unsigned int aom_sad_skip_64x32_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_64x32 aom_sad_skip_64x32_c
+
+void aom_sad_skip_64x32x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_64x32x4d aom_sad_skip_64x32x4d_c
+
+unsigned int aom_sad_skip_64x64_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_64x64 aom_sad_skip_64x64_c
+
+void aom_sad_skip_64x64x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_64x64x4d aom_sad_skip_64x64x4d_c
+
+unsigned int aom_sad_skip_8x16_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_8x16 aom_sad_skip_8x16_c
+
+void aom_sad_skip_8x16x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_8x16x4d aom_sad_skip_8x16x4d_c
+
+unsigned int aom_sad_skip_8x32_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_8x32 aom_sad_skip_8x32_c
+
+void aom_sad_skip_8x32x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_8x32x4d aom_sad_skip_8x32x4d_c
+
+unsigned int aom_sad_skip_8x4_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+#define aom_sad_skip_8x4 aom_sad_skip_8x4_c
+
+void aom_sad_skip_8x4x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+#define aom_sad_skip_8x4x4d aom_sad_skip_8x4x4d_c
+
+unsigned int aom_sad_skip_8x8_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+#define aom_sad_skip_8x8 aom_sad_skip_8x8_c
+
+void aom_sad_skip_8x8x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+#define aom_sad_skip_8x8x4d aom_sad_skip_8x8x4d_c
+
 int aom_satd_c(const tran_low_t* coeff, int length);
 int aom_satd_neon(const tran_low_t* coeff, int length);
 #define aom_satd aom_satd_neon

diff --git a/third_party/libaom/source/config/ios/arm-neon/config/av1_rtcd.h b/third_party/libaom/source/config/ios/arm-neon/config/av1_rtcd.h
index 60880ef..759f014e 100644
--- a/third_party/libaom/source/config/ios/arm-neon/config/av1_rtcd.h
+++ b/third_party/libaom/source/config/ios/arm-neon/config/av1_rtcd.h

@@ -848,6 +848,23 @@
                                   int8_t* const coeff_contexts);
 #define av1_get_nz_map_contexts av1_get_nz_map_contexts_neon
 
+void av1_highbd_apply_temporal_filter_c(
+    const struct yv12_buffer_config* ref_frame,
+    const struct macroblockd* mbd,
+    const BLOCK_SIZE block_size,
+    const int mb_row,
+    const int mb_col,
+    const int num_planes,
+    const double* noise_levels,
+    const MV* subblock_mvs,
+    const int* subblock_mses,
+    const int q_factor,
+    const int filter_strength,
+    const uint8_t* pred,
+    uint32_t* accum,
+    uint16_t* count);
+#define av1_highbd_apply_temporal_filter av1_highbd_apply_temporal_filter_c
+
 int64_t av1_highbd_block_error_c(const tran_low_t* coeff,
                                  const tran_low_t* dqcoeff,
                                  intptr_t block_size,

diff --git a/third_party/libaom/source/config/ios/arm64/config/aom_config.asm b/third_party/libaom/source/config/ios/arm64/config/aom_config.asm
index c72fccf..137f0909 100644
--- a/third_party/libaom/source/config/ios/arm64/config/aom_config.asm
+++ b/third_party/libaom/source/config/ios/arm64/config/aom_config.asm

@@ -43,6 +43,7 @@
 CONFIG_MULTITHREAD equ 1
 CONFIG_NN_V2 equ 0
 CONFIG_NORMAL_TILE_MODE equ 1
+CONFIG_OPTICAL_FLOW_API equ 0
 CONFIG_OS_SUPPORT equ 1
 CONFIG_PIC equ 0
 CONFIG_RD_DEBUG equ 0

diff --git a/third_party/libaom/source/config/ios/arm64/config/aom_config.h b/third_party/libaom/source/config/ios/arm64/config/aom_config.h
index c6d0bc38..927b683 100644
--- a/third_party/libaom/source/config/ios/arm64/config/aom_config.h
+++ b/third_party/libaom/source/config/ios/arm64/config/aom_config.h

@@ -45,6 +45,7 @@
 #define CONFIG_MULTITHREAD 1
 #define CONFIG_NN_V2 0
 #define CONFIG_NORMAL_TILE_MODE 1
+#define CONFIG_OPTICAL_FLOW_API 0
 #define CONFIG_OS_SUPPORT 1
 #define CONFIG_PIC 0
 #define CONFIG_RD_DEBUG 0

diff --git a/third_party/libaom/source/config/ios/arm64/config/aom_dsp_rtcd.h b/third_party/libaom/source/config/ios/arm64/config/aom_dsp_rtcd.h
index 0b7aca7..127d985 100644
--- a/third_party/libaom/source/config/ios/arm64/config/aom_dsp_rtcd.h
+++ b/third_party/libaom/source/config/ios/arm64/config/aom_dsp_rtcd.h

@@ -8789,6 +8789,292 @@
                             uint32_t* sad_array);
 #define aom_highbd_sad8x8x4d aom_highbd_sad8x8x4d_c
 
+unsigned int aom_highbd_sad_skip_128x128_c(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride);
+#define aom_highbd_sad_skip_128x128 aom_highbd_sad_skip_128x128_c
+
+void aom_highbd_sad_skip_128x128x4d_c(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* const ref_ptr[],
+                                      int ref_stride,
+                                      uint32_t* sad_array);
+#define aom_highbd_sad_skip_128x128x4d aom_highbd_sad_skip_128x128x4d_c
+
+unsigned int aom_highbd_sad_skip_128x64_c(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride);
+#define aom_highbd_sad_skip_128x64 aom_highbd_sad_skip_128x64_c
+
+void aom_highbd_sad_skip_128x64x4d_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* const ref_ptr[],
+                                     int ref_stride,
+                                     uint32_t* sad_array);
+#define aom_highbd_sad_skip_128x64x4d aom_highbd_sad_skip_128x64x4d_c
+
+unsigned int aom_highbd_sad_skip_16x16_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_16x16 aom_highbd_sad_skip_16x16_c
+
+void aom_highbd_sad_skip_16x16x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_16x16x4d aom_highbd_sad_skip_16x16x4d_c
+
+unsigned int aom_highbd_sad_skip_16x32_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_16x32 aom_highbd_sad_skip_16x32_c
+
+void aom_highbd_sad_skip_16x32x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_16x32x4d aom_highbd_sad_skip_16x32x4d_c
+
+unsigned int aom_highbd_sad_skip_16x4_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_16x4 aom_highbd_sad_skip_16x4_c
+
+void aom_highbd_sad_skip_16x4x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_16x4x4d aom_highbd_sad_skip_16x4x4d_c
+
+unsigned int aom_highbd_sad_skip_16x64_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_16x64 aom_highbd_sad_skip_16x64_c
+
+void aom_highbd_sad_skip_16x64x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_16x64x4d aom_highbd_sad_skip_16x64x4d_c
+
+unsigned int aom_highbd_sad_skip_16x8_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_16x8 aom_highbd_sad_skip_16x8_c
+
+void aom_highbd_sad_skip_16x8x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_16x8x4d aom_highbd_sad_skip_16x8x4d_c
+
+unsigned int aom_highbd_sad_skip_32x16_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_32x16 aom_highbd_sad_skip_32x16_c
+
+void aom_highbd_sad_skip_32x16x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_32x16x4d aom_highbd_sad_skip_32x16x4d_c
+
+unsigned int aom_highbd_sad_skip_32x32_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_32x32 aom_highbd_sad_skip_32x32_c
+
+void aom_highbd_sad_skip_32x32x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_32x32x4d aom_highbd_sad_skip_32x32x4d_c
+
+unsigned int aom_highbd_sad_skip_32x64_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_32x64 aom_highbd_sad_skip_32x64_c
+
+void aom_highbd_sad_skip_32x64x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_32x64x4d aom_highbd_sad_skip_32x64x4d_c
+
+unsigned int aom_highbd_sad_skip_32x8_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_32x8 aom_highbd_sad_skip_32x8_c
+
+void aom_highbd_sad_skip_32x8x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_32x8x4d aom_highbd_sad_skip_32x8x4d_c
+
+unsigned int aom_highbd_sad_skip_4x16_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_4x16 aom_highbd_sad_skip_4x16_c
+
+void aom_highbd_sad_skip_4x16x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_4x16x4d aom_highbd_sad_skip_4x16x4d_c
+
+unsigned int aom_highbd_sad_skip_4x4_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+#define aom_highbd_sad_skip_4x4 aom_highbd_sad_skip_4x4_c
+
+void aom_highbd_sad_skip_4x4x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+#define aom_highbd_sad_skip_4x4x4d aom_highbd_sad_skip_4x4x4d_c
+
+unsigned int aom_highbd_sad_skip_4x8_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+#define aom_highbd_sad_skip_4x8 aom_highbd_sad_skip_4x8_c
+
+void aom_highbd_sad_skip_4x8x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+#define aom_highbd_sad_skip_4x8x4d aom_highbd_sad_skip_4x8x4d_c
+
+unsigned int aom_highbd_sad_skip_64x128_c(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride);
+#define aom_highbd_sad_skip_64x128 aom_highbd_sad_skip_64x128_c
+
+void aom_highbd_sad_skip_64x128x4d_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* const ref_ptr[],
+                                     int ref_stride,
+                                     uint32_t* sad_array);
+#define aom_highbd_sad_skip_64x128x4d aom_highbd_sad_skip_64x128x4d_c
+
+unsigned int aom_highbd_sad_skip_64x16_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_64x16 aom_highbd_sad_skip_64x16_c
+
+void aom_highbd_sad_skip_64x16x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_64x16x4d aom_highbd_sad_skip_64x16x4d_c
+
+unsigned int aom_highbd_sad_skip_64x32_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_64x32 aom_highbd_sad_skip_64x32_c
+
+void aom_highbd_sad_skip_64x32x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_64x32x4d aom_highbd_sad_skip_64x32x4d_c
+
+unsigned int aom_highbd_sad_skip_64x64_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_64x64 aom_highbd_sad_skip_64x64_c
+
+void aom_highbd_sad_skip_64x64x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_64x64x4d aom_highbd_sad_skip_64x64x4d_c
+
+unsigned int aom_highbd_sad_skip_8x16_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_8x16 aom_highbd_sad_skip_8x16_c
+
+void aom_highbd_sad_skip_8x16x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x16x4d aom_highbd_sad_skip_8x16x4d_c
+
+unsigned int aom_highbd_sad_skip_8x32_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_8x32 aom_highbd_sad_skip_8x32_c
+
+void aom_highbd_sad_skip_8x32x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x32x4d aom_highbd_sad_skip_8x32x4d_c
+
+unsigned int aom_highbd_sad_skip_8x4_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+#define aom_highbd_sad_skip_8x4 aom_highbd_sad_skip_8x4_c
+
+void aom_highbd_sad_skip_8x4x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x4x4d aom_highbd_sad_skip_8x4x4d_c
+
+unsigned int aom_highbd_sad_skip_8x8_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+#define aom_highbd_sad_skip_8x8 aom_highbd_sad_skip_8x8_c
+
+void aom_highbd_sad_skip_8x8x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x8x4d aom_highbd_sad_skip_8x8x4d_c
+
 void aom_highbd_smooth_h_predictor_16x16_c(uint16_t* dst,
                                            ptrdiff_t y_stride,
                                            const uint16_t* above,
@@ -11884,6 +12170,292 @@
                           int height);
 #define aom_sad8xh aom_sad8xh_c
 
+unsigned int aom_sad_skip_128x128_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride);
+#define aom_sad_skip_128x128 aom_sad_skip_128x128_c
+
+void aom_sad_skip_128x128x4d_c(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+#define aom_sad_skip_128x128x4d aom_sad_skip_128x128x4d_c
+
+unsigned int aom_sad_skip_128x64_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+#define aom_sad_skip_128x64 aom_sad_skip_128x64_c
+
+void aom_sad_skip_128x64x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+#define aom_sad_skip_128x64x4d aom_sad_skip_128x64x4d_c
+
+unsigned int aom_sad_skip_16x16_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_16x16 aom_sad_skip_16x16_c
+
+void aom_sad_skip_16x16x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_16x16x4d aom_sad_skip_16x16x4d_c
+
+unsigned int aom_sad_skip_16x32_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_16x32 aom_sad_skip_16x32_c
+
+void aom_sad_skip_16x32x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_16x32x4d aom_sad_skip_16x32x4d_c
+
+unsigned int aom_sad_skip_16x4_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_16x4 aom_sad_skip_16x4_c
+
+void aom_sad_skip_16x4x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_16x4x4d aom_sad_skip_16x4x4d_c
+
+unsigned int aom_sad_skip_16x64_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_16x64 aom_sad_skip_16x64_c
+
+void aom_sad_skip_16x64x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_16x64x4d aom_sad_skip_16x64x4d_c
+
+unsigned int aom_sad_skip_16x8_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_16x8 aom_sad_skip_16x8_c
+
+void aom_sad_skip_16x8x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_16x8x4d aom_sad_skip_16x8x4d_c
+
+unsigned int aom_sad_skip_32x16_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_32x16 aom_sad_skip_32x16_c
+
+void aom_sad_skip_32x16x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_32x16x4d aom_sad_skip_32x16x4d_c
+
+unsigned int aom_sad_skip_32x32_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_32x32 aom_sad_skip_32x32_c
+
+void aom_sad_skip_32x32x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_32x32x4d aom_sad_skip_32x32x4d_c
+
+unsigned int aom_sad_skip_32x64_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_32x64 aom_sad_skip_32x64_c
+
+void aom_sad_skip_32x64x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_32x64x4d aom_sad_skip_32x64x4d_c
+
+unsigned int aom_sad_skip_32x8_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_32x8 aom_sad_skip_32x8_c
+
+void aom_sad_skip_32x8x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_32x8x4d aom_sad_skip_32x8x4d_c
+
+unsigned int aom_sad_skip_4x16_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_4x16 aom_sad_skip_4x16_c
+
+void aom_sad_skip_4x16x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_4x16x4d aom_sad_skip_4x16x4d_c
+
+unsigned int aom_sad_skip_4x4_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+#define aom_sad_skip_4x4 aom_sad_skip_4x4_c
+
+void aom_sad_skip_4x4x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+#define aom_sad_skip_4x4x4d aom_sad_skip_4x4x4d_c
+
+unsigned int aom_sad_skip_4x8_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+#define aom_sad_skip_4x8 aom_sad_skip_4x8_c
+
+void aom_sad_skip_4x8x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+#define aom_sad_skip_4x8x4d aom_sad_skip_4x8x4d_c
+
+unsigned int aom_sad_skip_64x128_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+#define aom_sad_skip_64x128 aom_sad_skip_64x128_c
+
+void aom_sad_skip_64x128x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+#define aom_sad_skip_64x128x4d aom_sad_skip_64x128x4d_c
+
+unsigned int aom_sad_skip_64x16_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_64x16 aom_sad_skip_64x16_c
+
+void aom_sad_skip_64x16x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_64x16x4d aom_sad_skip_64x16x4d_c
+
+unsigned int aom_sad_skip_64x32_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_64x32 aom_sad_skip_64x32_c
+
+void aom_sad_skip_64x32x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_64x32x4d aom_sad_skip_64x32x4d_c
+
+unsigned int aom_sad_skip_64x64_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_64x64 aom_sad_skip_64x64_c
+
+void aom_sad_skip_64x64x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_64x64x4d aom_sad_skip_64x64x4d_c
+
+unsigned int aom_sad_skip_8x16_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_8x16 aom_sad_skip_8x16_c
+
+void aom_sad_skip_8x16x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_8x16x4d aom_sad_skip_8x16x4d_c
+
+unsigned int aom_sad_skip_8x32_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_8x32 aom_sad_skip_8x32_c
+
+void aom_sad_skip_8x32x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_8x32x4d aom_sad_skip_8x32x4d_c
+
+unsigned int aom_sad_skip_8x4_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+#define aom_sad_skip_8x4 aom_sad_skip_8x4_c
+
+void aom_sad_skip_8x4x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+#define aom_sad_skip_8x4x4d aom_sad_skip_8x4x4d_c
+
+unsigned int aom_sad_skip_8x8_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+#define aom_sad_skip_8x8 aom_sad_skip_8x8_c
+
+void aom_sad_skip_8x8x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+#define aom_sad_skip_8x8x4d aom_sad_skip_8x8x4d_c
+
 int aom_satd_c(const tran_low_t* coeff, int length);
 int aom_satd_neon(const tran_low_t* coeff, int length);
 #define aom_satd aom_satd_neon

diff --git a/third_party/libaom/source/config/ios/arm64/config/av1_rtcd.h b/third_party/libaom/source/config/ios/arm64/config/av1_rtcd.h
index 60880ef..759f014e 100644
--- a/third_party/libaom/source/config/ios/arm64/config/av1_rtcd.h
+++ b/third_party/libaom/source/config/ios/arm64/config/av1_rtcd.h

@@ -848,6 +848,23 @@
                                   int8_t* const coeff_contexts);
 #define av1_get_nz_map_contexts av1_get_nz_map_contexts_neon
 
+void av1_highbd_apply_temporal_filter_c(
+    const struct yv12_buffer_config* ref_frame,
+    const struct macroblockd* mbd,
+    const BLOCK_SIZE block_size,
+    const int mb_row,
+    const int mb_col,
+    const int num_planes,
+    const double* noise_levels,
+    const MV* subblock_mvs,
+    const int* subblock_mses,
+    const int q_factor,
+    const int filter_strength,
+    const uint8_t* pred,
+    uint32_t* accum,
+    uint16_t* count);
+#define av1_highbd_apply_temporal_filter av1_highbd_apply_temporal_filter_c
+
 int64_t av1_highbd_block_error_c(const tran_low_t* coeff,
                                  const tran_low_t* dqcoeff,
                                  intptr_t block_size,

diff --git a/third_party/libaom/source/config/linux/arm-neon-cpu-detect/config/aom_config.asm b/third_party/libaom/source/config/linux/arm-neon-cpu-detect/config/aom_config.asm
index cb0bfd68..44cabfd 100644
--- a/third_party/libaom/source/config/linux/arm-neon-cpu-detect/config/aom_config.asm
+++ b/third_party/libaom/source/config/linux/arm-neon-cpu-detect/config/aom_config.asm

@@ -43,6 +43,7 @@
 CONFIG_MULTITHREAD equ 1
 CONFIG_NN_V2 equ 0
 CONFIG_NORMAL_TILE_MODE equ 1
+CONFIG_OPTICAL_FLOW_API equ 0
 CONFIG_OS_SUPPORT equ 1
 CONFIG_PIC equ 0
 CONFIG_RD_DEBUG equ 0

diff --git a/third_party/libaom/source/config/linux/arm-neon-cpu-detect/config/aom_config.h b/third_party/libaom/source/config/linux/arm-neon-cpu-detect/config/aom_config.h
index 7743107..9eeef957 100644
--- a/third_party/libaom/source/config/linux/arm-neon-cpu-detect/config/aom_config.h
+++ b/third_party/libaom/source/config/linux/arm-neon-cpu-detect/config/aom_config.h

@@ -45,6 +45,7 @@
 #define CONFIG_MULTITHREAD 1
 #define CONFIG_NN_V2 0
 #define CONFIG_NORMAL_TILE_MODE 1
+#define CONFIG_OPTICAL_FLOW_API 0
 #define CONFIG_OS_SUPPORT 1
 #define CONFIG_PIC 0
 #define CONFIG_RD_DEBUG 0

diff --git a/third_party/libaom/source/config/linux/arm-neon-cpu-detect/config/aom_dsp_rtcd.h b/third_party/libaom/source/config/linux/arm-neon-cpu-detect/config/aom_dsp_rtcd.h
index 1760b9e..30b7446d 100644
--- a/third_party/libaom/source/config/linux/arm-neon-cpu-detect/config/aom_dsp_rtcd.h
+++ b/third_party/libaom/source/config/linux/arm-neon-cpu-detect/config/aom_dsp_rtcd.h

@@ -8917,6 +8917,292 @@
                             uint32_t* sad_array);
 #define aom_highbd_sad8x8x4d aom_highbd_sad8x8x4d_c
 
+unsigned int aom_highbd_sad_skip_128x128_c(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride);
+#define aom_highbd_sad_skip_128x128 aom_highbd_sad_skip_128x128_c
+
+void aom_highbd_sad_skip_128x128x4d_c(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* const ref_ptr[],
+                                      int ref_stride,
+                                      uint32_t* sad_array);
+#define aom_highbd_sad_skip_128x128x4d aom_highbd_sad_skip_128x128x4d_c
+
+unsigned int aom_highbd_sad_skip_128x64_c(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride);
+#define aom_highbd_sad_skip_128x64 aom_highbd_sad_skip_128x64_c
+
+void aom_highbd_sad_skip_128x64x4d_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* const ref_ptr[],
+                                     int ref_stride,
+                                     uint32_t* sad_array);
+#define aom_highbd_sad_skip_128x64x4d aom_highbd_sad_skip_128x64x4d_c
+
+unsigned int aom_highbd_sad_skip_16x16_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_16x16 aom_highbd_sad_skip_16x16_c
+
+void aom_highbd_sad_skip_16x16x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_16x16x4d aom_highbd_sad_skip_16x16x4d_c
+
+unsigned int aom_highbd_sad_skip_16x32_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_16x32 aom_highbd_sad_skip_16x32_c
+
+void aom_highbd_sad_skip_16x32x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_16x32x4d aom_highbd_sad_skip_16x32x4d_c
+
+unsigned int aom_highbd_sad_skip_16x4_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_16x4 aom_highbd_sad_skip_16x4_c
+
+void aom_highbd_sad_skip_16x4x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_16x4x4d aom_highbd_sad_skip_16x4x4d_c
+
+unsigned int aom_highbd_sad_skip_16x64_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_16x64 aom_highbd_sad_skip_16x64_c
+
+void aom_highbd_sad_skip_16x64x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_16x64x4d aom_highbd_sad_skip_16x64x4d_c
+
+unsigned int aom_highbd_sad_skip_16x8_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_16x8 aom_highbd_sad_skip_16x8_c
+
+void aom_highbd_sad_skip_16x8x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_16x8x4d aom_highbd_sad_skip_16x8x4d_c
+
+unsigned int aom_highbd_sad_skip_32x16_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_32x16 aom_highbd_sad_skip_32x16_c
+
+void aom_highbd_sad_skip_32x16x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_32x16x4d aom_highbd_sad_skip_32x16x4d_c
+
+unsigned int aom_highbd_sad_skip_32x32_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_32x32 aom_highbd_sad_skip_32x32_c
+
+void aom_highbd_sad_skip_32x32x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_32x32x4d aom_highbd_sad_skip_32x32x4d_c
+
+unsigned int aom_highbd_sad_skip_32x64_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_32x64 aom_highbd_sad_skip_32x64_c
+
+void aom_highbd_sad_skip_32x64x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_32x64x4d aom_highbd_sad_skip_32x64x4d_c
+
+unsigned int aom_highbd_sad_skip_32x8_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_32x8 aom_highbd_sad_skip_32x8_c
+
+void aom_highbd_sad_skip_32x8x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_32x8x4d aom_highbd_sad_skip_32x8x4d_c
+
+unsigned int aom_highbd_sad_skip_4x16_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_4x16 aom_highbd_sad_skip_4x16_c
+
+void aom_highbd_sad_skip_4x16x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_4x16x4d aom_highbd_sad_skip_4x16x4d_c
+
+unsigned int aom_highbd_sad_skip_4x4_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+#define aom_highbd_sad_skip_4x4 aom_highbd_sad_skip_4x4_c
+
+void aom_highbd_sad_skip_4x4x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+#define aom_highbd_sad_skip_4x4x4d aom_highbd_sad_skip_4x4x4d_c
+
+unsigned int aom_highbd_sad_skip_4x8_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+#define aom_highbd_sad_skip_4x8 aom_highbd_sad_skip_4x8_c
+
+void aom_highbd_sad_skip_4x8x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+#define aom_highbd_sad_skip_4x8x4d aom_highbd_sad_skip_4x8x4d_c
+
+unsigned int aom_highbd_sad_skip_64x128_c(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride);
+#define aom_highbd_sad_skip_64x128 aom_highbd_sad_skip_64x128_c
+
+void aom_highbd_sad_skip_64x128x4d_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* const ref_ptr[],
+                                     int ref_stride,
+                                     uint32_t* sad_array);
+#define aom_highbd_sad_skip_64x128x4d aom_highbd_sad_skip_64x128x4d_c
+
+unsigned int aom_highbd_sad_skip_64x16_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_64x16 aom_highbd_sad_skip_64x16_c
+
+void aom_highbd_sad_skip_64x16x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_64x16x4d aom_highbd_sad_skip_64x16x4d_c
+
+unsigned int aom_highbd_sad_skip_64x32_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_64x32 aom_highbd_sad_skip_64x32_c
+
+void aom_highbd_sad_skip_64x32x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_64x32x4d aom_highbd_sad_skip_64x32x4d_c
+
+unsigned int aom_highbd_sad_skip_64x64_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_64x64 aom_highbd_sad_skip_64x64_c
+
+void aom_highbd_sad_skip_64x64x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_64x64x4d aom_highbd_sad_skip_64x64x4d_c
+
+unsigned int aom_highbd_sad_skip_8x16_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_8x16 aom_highbd_sad_skip_8x16_c
+
+void aom_highbd_sad_skip_8x16x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x16x4d aom_highbd_sad_skip_8x16x4d_c
+
+unsigned int aom_highbd_sad_skip_8x32_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_8x32 aom_highbd_sad_skip_8x32_c
+
+void aom_highbd_sad_skip_8x32x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x32x4d aom_highbd_sad_skip_8x32x4d_c
+
+unsigned int aom_highbd_sad_skip_8x4_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+#define aom_highbd_sad_skip_8x4 aom_highbd_sad_skip_8x4_c
+
+void aom_highbd_sad_skip_8x4x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x4x4d aom_highbd_sad_skip_8x4x4d_c
+
+unsigned int aom_highbd_sad_skip_8x8_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+#define aom_highbd_sad_skip_8x8 aom_highbd_sad_skip_8x8_c
+
+void aom_highbd_sad_skip_8x8x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x8x4d aom_highbd_sad_skip_8x8x4d_c
+
 void aom_highbd_smooth_h_predictor_16x16_c(uint16_t* dst,
                                            ptrdiff_t y_stride,
                                            const uint16_t* above,
@@ -12137,6 +12423,292 @@
                           int height);
 #define aom_sad8xh aom_sad8xh_c
 
+unsigned int aom_sad_skip_128x128_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride);
+#define aom_sad_skip_128x128 aom_sad_skip_128x128_c
+
+void aom_sad_skip_128x128x4d_c(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+#define aom_sad_skip_128x128x4d aom_sad_skip_128x128x4d_c
+
+unsigned int aom_sad_skip_128x64_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+#define aom_sad_skip_128x64 aom_sad_skip_128x64_c
+
+void aom_sad_skip_128x64x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+#define aom_sad_skip_128x64x4d aom_sad_skip_128x64x4d_c
+
+unsigned int aom_sad_skip_16x16_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_16x16 aom_sad_skip_16x16_c
+
+void aom_sad_skip_16x16x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_16x16x4d aom_sad_skip_16x16x4d_c
+
+unsigned int aom_sad_skip_16x32_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_16x32 aom_sad_skip_16x32_c
+
+void aom_sad_skip_16x32x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_16x32x4d aom_sad_skip_16x32x4d_c
+
+unsigned int aom_sad_skip_16x4_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_16x4 aom_sad_skip_16x4_c
+
+void aom_sad_skip_16x4x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_16x4x4d aom_sad_skip_16x4x4d_c
+
+unsigned int aom_sad_skip_16x64_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_16x64 aom_sad_skip_16x64_c
+
+void aom_sad_skip_16x64x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_16x64x4d aom_sad_skip_16x64x4d_c
+
+unsigned int aom_sad_skip_16x8_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_16x8 aom_sad_skip_16x8_c
+
+void aom_sad_skip_16x8x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_16x8x4d aom_sad_skip_16x8x4d_c
+
+unsigned int aom_sad_skip_32x16_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_32x16 aom_sad_skip_32x16_c
+
+void aom_sad_skip_32x16x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_32x16x4d aom_sad_skip_32x16x4d_c
+
+unsigned int aom_sad_skip_32x32_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_32x32 aom_sad_skip_32x32_c
+
+void aom_sad_skip_32x32x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_32x32x4d aom_sad_skip_32x32x4d_c
+
+unsigned int aom_sad_skip_32x64_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_32x64 aom_sad_skip_32x64_c
+
+void aom_sad_skip_32x64x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_32x64x4d aom_sad_skip_32x64x4d_c
+
+unsigned int aom_sad_skip_32x8_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_32x8 aom_sad_skip_32x8_c
+
+void aom_sad_skip_32x8x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_32x8x4d aom_sad_skip_32x8x4d_c
+
+unsigned int aom_sad_skip_4x16_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_4x16 aom_sad_skip_4x16_c
+
+void aom_sad_skip_4x16x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_4x16x4d aom_sad_skip_4x16x4d_c
+
+unsigned int aom_sad_skip_4x4_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+#define aom_sad_skip_4x4 aom_sad_skip_4x4_c
+
+void aom_sad_skip_4x4x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+#define aom_sad_skip_4x4x4d aom_sad_skip_4x4x4d_c
+
+unsigned int aom_sad_skip_4x8_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+#define aom_sad_skip_4x8 aom_sad_skip_4x8_c
+
+void aom_sad_skip_4x8x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+#define aom_sad_skip_4x8x4d aom_sad_skip_4x8x4d_c
+
+unsigned int aom_sad_skip_64x128_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+#define aom_sad_skip_64x128 aom_sad_skip_64x128_c
+
+void aom_sad_skip_64x128x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+#define aom_sad_skip_64x128x4d aom_sad_skip_64x128x4d_c
+
+unsigned int aom_sad_skip_64x16_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_64x16 aom_sad_skip_64x16_c
+
+void aom_sad_skip_64x16x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_64x16x4d aom_sad_skip_64x16x4d_c
+
+unsigned int aom_sad_skip_64x32_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_64x32 aom_sad_skip_64x32_c
+
+void aom_sad_skip_64x32x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_64x32x4d aom_sad_skip_64x32x4d_c
+
+unsigned int aom_sad_skip_64x64_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_64x64 aom_sad_skip_64x64_c
+
+void aom_sad_skip_64x64x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_64x64x4d aom_sad_skip_64x64x4d_c
+
+unsigned int aom_sad_skip_8x16_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_8x16 aom_sad_skip_8x16_c
+
+void aom_sad_skip_8x16x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_8x16x4d aom_sad_skip_8x16x4d_c
+
+unsigned int aom_sad_skip_8x32_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_8x32 aom_sad_skip_8x32_c
+
+void aom_sad_skip_8x32x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_8x32x4d aom_sad_skip_8x32x4d_c
+
+unsigned int aom_sad_skip_8x4_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+#define aom_sad_skip_8x4 aom_sad_skip_8x4_c
+
+void aom_sad_skip_8x4x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+#define aom_sad_skip_8x4x4d aom_sad_skip_8x4x4d_c
+
+unsigned int aom_sad_skip_8x8_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+#define aom_sad_skip_8x8 aom_sad_skip_8x8_c
+
+void aom_sad_skip_8x8x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+#define aom_sad_skip_8x8x4d aom_sad_skip_8x8x4d_c
+
 int aom_satd_c(const tran_low_t* coeff, int length);
 int aom_satd_neon(const tran_low_t* coeff, int length);
 RTCD_EXTERN int (*aom_satd)(const tran_low_t* coeff, int length);

diff --git a/third_party/libaom/source/config/linux/arm-neon-cpu-detect/config/av1_rtcd.h b/third_party/libaom/source/config/linux/arm-neon-cpu-detect/config/av1_rtcd.h
index 343dcb3..a3ddc96b 100644
--- a/third_party/libaom/source/config/linux/arm-neon-cpu-detect/config/av1_rtcd.h
+++ b/third_party/libaom/source/config/linux/arm-neon-cpu-detect/config/av1_rtcd.h

@@ -1065,6 +1065,23 @@
                                             const TX_CLASS tx_class,
                                             int8_t* const coeff_contexts);
 
+void av1_highbd_apply_temporal_filter_c(
+    const struct yv12_buffer_config* ref_frame,
+    const struct macroblockd* mbd,
+    const BLOCK_SIZE block_size,
+    const int mb_row,
+    const int mb_col,
+    const int num_planes,
+    const double* noise_levels,
+    const MV* subblock_mvs,
+    const int* subblock_mses,
+    const int q_factor,
+    const int filter_strength,
+    const uint8_t* pred,
+    uint32_t* accum,
+    uint16_t* count);
+#define av1_highbd_apply_temporal_filter av1_highbd_apply_temporal_filter_c
+
 int64_t av1_highbd_block_error_c(const tran_low_t* coeff,
                                  const tran_low_t* dqcoeff,
                                  intptr_t block_size,

diff --git a/third_party/libaom/source/config/linux/arm-neon/config/aom_config.asm b/third_party/libaom/source/config/linux/arm-neon/config/aom_config.asm
index c72fccf..137f0909 100644
--- a/third_party/libaom/source/config/linux/arm-neon/config/aom_config.asm
+++ b/third_party/libaom/source/config/linux/arm-neon/config/aom_config.asm

@@ -43,6 +43,7 @@
 CONFIG_MULTITHREAD equ 1
 CONFIG_NN_V2 equ 0
 CONFIG_NORMAL_TILE_MODE equ 1
+CONFIG_OPTICAL_FLOW_API equ 0
 CONFIG_OS_SUPPORT equ 1
 CONFIG_PIC equ 0
 CONFIG_RD_DEBUG equ 0

diff --git a/third_party/libaom/source/config/linux/arm-neon/config/aom_config.h b/third_party/libaom/source/config/linux/arm-neon/config/aom_config.h
index c6d0bc38..927b683 100644
--- a/third_party/libaom/source/config/linux/arm-neon/config/aom_config.h
+++ b/third_party/libaom/source/config/linux/arm-neon/config/aom_config.h

@@ -45,6 +45,7 @@
 #define CONFIG_MULTITHREAD 1
 #define CONFIG_NN_V2 0
 #define CONFIG_NORMAL_TILE_MODE 1
+#define CONFIG_OPTICAL_FLOW_API 0
 #define CONFIG_OS_SUPPORT 1
 #define CONFIG_PIC 0
 #define CONFIG_RD_DEBUG 0

diff --git a/third_party/libaom/source/config/linux/arm-neon/config/aom_dsp_rtcd.h b/third_party/libaom/source/config/linux/arm-neon/config/aom_dsp_rtcd.h
index 0b7aca7..127d985 100644
--- a/third_party/libaom/source/config/linux/arm-neon/config/aom_dsp_rtcd.h
+++ b/third_party/libaom/source/config/linux/arm-neon/config/aom_dsp_rtcd.h

@@ -8789,6 +8789,292 @@
                             uint32_t* sad_array);
 #define aom_highbd_sad8x8x4d aom_highbd_sad8x8x4d_c
 
+unsigned int aom_highbd_sad_skip_128x128_c(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride);
+#define aom_highbd_sad_skip_128x128 aom_highbd_sad_skip_128x128_c
+
+void aom_highbd_sad_skip_128x128x4d_c(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* const ref_ptr[],
+                                      int ref_stride,
+                                      uint32_t* sad_array);
+#define aom_highbd_sad_skip_128x128x4d aom_highbd_sad_skip_128x128x4d_c
+
+unsigned int aom_highbd_sad_skip_128x64_c(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride);
+#define aom_highbd_sad_skip_128x64 aom_highbd_sad_skip_128x64_c
+
+void aom_highbd_sad_skip_128x64x4d_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* const ref_ptr[],
+                                     int ref_stride,
+                                     uint32_t* sad_array);
+#define aom_highbd_sad_skip_128x64x4d aom_highbd_sad_skip_128x64x4d_c
+
+unsigned int aom_highbd_sad_skip_16x16_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_16x16 aom_highbd_sad_skip_16x16_c
+
+void aom_highbd_sad_skip_16x16x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_16x16x4d aom_highbd_sad_skip_16x16x4d_c
+
+unsigned int aom_highbd_sad_skip_16x32_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_16x32 aom_highbd_sad_skip_16x32_c
+
+void aom_highbd_sad_skip_16x32x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_16x32x4d aom_highbd_sad_skip_16x32x4d_c
+
+unsigned int aom_highbd_sad_skip_16x4_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_16x4 aom_highbd_sad_skip_16x4_c
+
+void aom_highbd_sad_skip_16x4x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_16x4x4d aom_highbd_sad_skip_16x4x4d_c
+
+unsigned int aom_highbd_sad_skip_16x64_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_16x64 aom_highbd_sad_skip_16x64_c
+
+void aom_highbd_sad_skip_16x64x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_16x64x4d aom_highbd_sad_skip_16x64x4d_c
+
+unsigned int aom_highbd_sad_skip_16x8_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_16x8 aom_highbd_sad_skip_16x8_c
+
+void aom_highbd_sad_skip_16x8x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_16x8x4d aom_highbd_sad_skip_16x8x4d_c
+
+unsigned int aom_highbd_sad_skip_32x16_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_32x16 aom_highbd_sad_skip_32x16_c
+
+void aom_highbd_sad_skip_32x16x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_32x16x4d aom_highbd_sad_skip_32x16x4d_c
+
+unsigned int aom_highbd_sad_skip_32x32_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_32x32 aom_highbd_sad_skip_32x32_c
+
+void aom_highbd_sad_skip_32x32x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_32x32x4d aom_highbd_sad_skip_32x32x4d_c
+
+unsigned int aom_highbd_sad_skip_32x64_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_32x64 aom_highbd_sad_skip_32x64_c
+
+void aom_highbd_sad_skip_32x64x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_32x64x4d aom_highbd_sad_skip_32x64x4d_c
+
+unsigned int aom_highbd_sad_skip_32x8_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_32x8 aom_highbd_sad_skip_32x8_c
+
+void aom_highbd_sad_skip_32x8x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_32x8x4d aom_highbd_sad_skip_32x8x4d_c
+
+unsigned int aom_highbd_sad_skip_4x16_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_4x16 aom_highbd_sad_skip_4x16_c
+
+void aom_highbd_sad_skip_4x16x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_4x16x4d aom_highbd_sad_skip_4x16x4d_c
+
+unsigned int aom_highbd_sad_skip_4x4_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+#define aom_highbd_sad_skip_4x4 aom_highbd_sad_skip_4x4_c
+
+void aom_highbd_sad_skip_4x4x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+#define aom_highbd_sad_skip_4x4x4d aom_highbd_sad_skip_4x4x4d_c
+
+unsigned int aom_highbd_sad_skip_4x8_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+#define aom_highbd_sad_skip_4x8 aom_highbd_sad_skip_4x8_c
+
+void aom_highbd_sad_skip_4x8x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+#define aom_highbd_sad_skip_4x8x4d aom_highbd_sad_skip_4x8x4d_c
+
+unsigned int aom_highbd_sad_skip_64x128_c(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride);
+#define aom_highbd_sad_skip_64x128 aom_highbd_sad_skip_64x128_c
+
+void aom_highbd_sad_skip_64x128x4d_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* const ref_ptr[],
+                                     int ref_stride,
+                                     uint32_t* sad_array);
+#define aom_highbd_sad_skip_64x128x4d aom_highbd_sad_skip_64x128x4d_c
+
+unsigned int aom_highbd_sad_skip_64x16_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_64x16 aom_highbd_sad_skip_64x16_c
+
+void aom_highbd_sad_skip_64x16x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_64x16x4d aom_highbd_sad_skip_64x16x4d_c
+
+unsigned int aom_highbd_sad_skip_64x32_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_64x32 aom_highbd_sad_skip_64x32_c
+
+void aom_highbd_sad_skip_64x32x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_64x32x4d aom_highbd_sad_skip_64x32x4d_c
+
+unsigned int aom_highbd_sad_skip_64x64_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_64x64 aom_highbd_sad_skip_64x64_c
+
+void aom_highbd_sad_skip_64x64x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_64x64x4d aom_highbd_sad_skip_64x64x4d_c
+
+unsigned int aom_highbd_sad_skip_8x16_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_8x16 aom_highbd_sad_skip_8x16_c
+
+void aom_highbd_sad_skip_8x16x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x16x4d aom_highbd_sad_skip_8x16x4d_c
+
+unsigned int aom_highbd_sad_skip_8x32_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_8x32 aom_highbd_sad_skip_8x32_c
+
+void aom_highbd_sad_skip_8x32x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x32x4d aom_highbd_sad_skip_8x32x4d_c
+
+unsigned int aom_highbd_sad_skip_8x4_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+#define aom_highbd_sad_skip_8x4 aom_highbd_sad_skip_8x4_c
+
+void aom_highbd_sad_skip_8x4x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x4x4d aom_highbd_sad_skip_8x4x4d_c
+
+unsigned int aom_highbd_sad_skip_8x8_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+#define aom_highbd_sad_skip_8x8 aom_highbd_sad_skip_8x8_c
+
+void aom_highbd_sad_skip_8x8x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x8x4d aom_highbd_sad_skip_8x8x4d_c
+
 void aom_highbd_smooth_h_predictor_16x16_c(uint16_t* dst,
                                            ptrdiff_t y_stride,
                                            const uint16_t* above,
@@ -11884,6 +12170,292 @@
                           int height);
 #define aom_sad8xh aom_sad8xh_c
 
+unsigned int aom_sad_skip_128x128_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride);
+#define aom_sad_skip_128x128 aom_sad_skip_128x128_c
+
+void aom_sad_skip_128x128x4d_c(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+#define aom_sad_skip_128x128x4d aom_sad_skip_128x128x4d_c
+
+unsigned int aom_sad_skip_128x64_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+#define aom_sad_skip_128x64 aom_sad_skip_128x64_c
+
+void aom_sad_skip_128x64x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+#define aom_sad_skip_128x64x4d aom_sad_skip_128x64x4d_c
+
+unsigned int aom_sad_skip_16x16_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_16x16 aom_sad_skip_16x16_c
+
+void aom_sad_skip_16x16x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_16x16x4d aom_sad_skip_16x16x4d_c
+
+unsigned int aom_sad_skip_16x32_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_16x32 aom_sad_skip_16x32_c
+
+void aom_sad_skip_16x32x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_16x32x4d aom_sad_skip_16x32x4d_c
+
+unsigned int aom_sad_skip_16x4_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_16x4 aom_sad_skip_16x4_c
+
+void aom_sad_skip_16x4x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_16x4x4d aom_sad_skip_16x4x4d_c
+
+unsigned int aom_sad_skip_16x64_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_16x64 aom_sad_skip_16x64_c
+
+void aom_sad_skip_16x64x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_16x64x4d aom_sad_skip_16x64x4d_c
+
+unsigned int aom_sad_skip_16x8_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_16x8 aom_sad_skip_16x8_c
+
+void aom_sad_skip_16x8x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_16x8x4d aom_sad_skip_16x8x4d_c
+
+unsigned int aom_sad_skip_32x16_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_32x16 aom_sad_skip_32x16_c
+
+void aom_sad_skip_32x16x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_32x16x4d aom_sad_skip_32x16x4d_c
+
+unsigned int aom_sad_skip_32x32_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_32x32 aom_sad_skip_32x32_c
+
+void aom_sad_skip_32x32x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_32x32x4d aom_sad_skip_32x32x4d_c
+
+unsigned int aom_sad_skip_32x64_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_32x64 aom_sad_skip_32x64_c
+
+void aom_sad_skip_32x64x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_32x64x4d aom_sad_skip_32x64x4d_c
+
+unsigned int aom_sad_skip_32x8_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_32x8 aom_sad_skip_32x8_c
+
+void aom_sad_skip_32x8x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_32x8x4d aom_sad_skip_32x8x4d_c
+
+unsigned int aom_sad_skip_4x16_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_4x16 aom_sad_skip_4x16_c
+
+void aom_sad_skip_4x16x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_4x16x4d aom_sad_skip_4x16x4d_c
+
+unsigned int aom_sad_skip_4x4_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+#define aom_sad_skip_4x4 aom_sad_skip_4x4_c
+
+void aom_sad_skip_4x4x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+#define aom_sad_skip_4x4x4d aom_sad_skip_4x4x4d_c
+
+unsigned int aom_sad_skip_4x8_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+#define aom_sad_skip_4x8 aom_sad_skip_4x8_c
+
+void aom_sad_skip_4x8x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+#define aom_sad_skip_4x8x4d aom_sad_skip_4x8x4d_c
+
+unsigned int aom_sad_skip_64x128_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+#define aom_sad_skip_64x128 aom_sad_skip_64x128_c
+
+void aom_sad_skip_64x128x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+#define aom_sad_skip_64x128x4d aom_sad_skip_64x128x4d_c
+
+unsigned int aom_sad_skip_64x16_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_64x16 aom_sad_skip_64x16_c
+
+void aom_sad_skip_64x16x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_64x16x4d aom_sad_skip_64x16x4d_c
+
+unsigned int aom_sad_skip_64x32_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_64x32 aom_sad_skip_64x32_c
+
+void aom_sad_skip_64x32x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_64x32x4d aom_sad_skip_64x32x4d_c
+
+unsigned int aom_sad_skip_64x64_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_64x64 aom_sad_skip_64x64_c
+
+void aom_sad_skip_64x64x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_64x64x4d aom_sad_skip_64x64x4d_c
+
+unsigned int aom_sad_skip_8x16_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_8x16 aom_sad_skip_8x16_c
+
+void aom_sad_skip_8x16x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_8x16x4d aom_sad_skip_8x16x4d_c
+
+unsigned int aom_sad_skip_8x32_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_8x32 aom_sad_skip_8x32_c
+
+void aom_sad_skip_8x32x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_8x32x4d aom_sad_skip_8x32x4d_c
+
+unsigned int aom_sad_skip_8x4_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+#define aom_sad_skip_8x4 aom_sad_skip_8x4_c
+
+void aom_sad_skip_8x4x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+#define aom_sad_skip_8x4x4d aom_sad_skip_8x4x4d_c
+
+unsigned int aom_sad_skip_8x8_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+#define aom_sad_skip_8x8 aom_sad_skip_8x8_c
+
+void aom_sad_skip_8x8x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+#define aom_sad_skip_8x8x4d aom_sad_skip_8x8x4d_c
+
 int aom_satd_c(const tran_low_t* coeff, int length);
 int aom_satd_neon(const tran_low_t* coeff, int length);
 #define aom_satd aom_satd_neon

diff --git a/third_party/libaom/source/config/linux/arm-neon/config/av1_rtcd.h b/third_party/libaom/source/config/linux/arm-neon/config/av1_rtcd.h
index 60880ef..759f014e 100644
--- a/third_party/libaom/source/config/linux/arm-neon/config/av1_rtcd.h
+++ b/third_party/libaom/source/config/linux/arm-neon/config/av1_rtcd.h

@@ -848,6 +848,23 @@
                                   int8_t* const coeff_contexts);
 #define av1_get_nz_map_contexts av1_get_nz_map_contexts_neon
 
+void av1_highbd_apply_temporal_filter_c(
+    const struct yv12_buffer_config* ref_frame,
+    const struct macroblockd* mbd,
+    const BLOCK_SIZE block_size,
+    const int mb_row,
+    const int mb_col,
+    const int num_planes,
+    const double* noise_levels,
+    const MV* subblock_mvs,
+    const int* subblock_mses,
+    const int q_factor,
+    const int filter_strength,
+    const uint8_t* pred,
+    uint32_t* accum,
+    uint16_t* count);
+#define av1_highbd_apply_temporal_filter av1_highbd_apply_temporal_filter_c
+
 int64_t av1_highbd_block_error_c(const tran_low_t* coeff,
                                  const tran_low_t* dqcoeff,
                                  intptr_t block_size,

diff --git a/third_party/libaom/source/config/linux/arm/config/aom_config.asm b/third_party/libaom/source/config/linux/arm/config/aom_config.asm
index eb4b1a1..809dc4e 100644
--- a/third_party/libaom/source/config/linux/arm/config/aom_config.asm
+++ b/third_party/libaom/source/config/linux/arm/config/aom_config.asm

@@ -43,6 +43,7 @@
 CONFIG_MULTITHREAD equ 1
 CONFIG_NN_V2 equ 0
 CONFIG_NORMAL_TILE_MODE equ 1
+CONFIG_OPTICAL_FLOW_API equ 0
 CONFIG_OS_SUPPORT equ 1
 CONFIG_PIC equ 0
 CONFIG_RD_DEBUG equ 0

diff --git a/third_party/libaom/source/config/linux/arm/config/aom_config.h b/third_party/libaom/source/config/linux/arm/config/aom_config.h
index 02e160a..a4b576c 100644
--- a/third_party/libaom/source/config/linux/arm/config/aom_config.h
+++ b/third_party/libaom/source/config/linux/arm/config/aom_config.h

@@ -45,6 +45,7 @@
 #define CONFIG_MULTITHREAD 1
 #define CONFIG_NN_V2 0
 #define CONFIG_NORMAL_TILE_MODE 1
+#define CONFIG_OPTICAL_FLOW_API 0
 #define CONFIG_OS_SUPPORT 1
 #define CONFIG_PIC 0
 #define CONFIG_RD_DEBUG 0

diff --git a/third_party/libaom/source/config/linux/arm/config/aom_dsp_rtcd.h b/third_party/libaom/source/config/linux/arm/config/aom_dsp_rtcd.h
index 495e9d3..b9f676b 100644
--- a/third_party/libaom/source/config/linux/arm/config/aom_dsp_rtcd.h
+++ b/third_party/libaom/source/config/linux/arm/config/aom_dsp_rtcd.h

@@ -8627,6 +8627,292 @@
                             uint32_t* sad_array);
 #define aom_highbd_sad8x8x4d aom_highbd_sad8x8x4d_c
 
+unsigned int aom_highbd_sad_skip_128x128_c(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride);
+#define aom_highbd_sad_skip_128x128 aom_highbd_sad_skip_128x128_c
+
+void aom_highbd_sad_skip_128x128x4d_c(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* const ref_ptr[],
+                                      int ref_stride,
+                                      uint32_t* sad_array);
+#define aom_highbd_sad_skip_128x128x4d aom_highbd_sad_skip_128x128x4d_c
+
+unsigned int aom_highbd_sad_skip_128x64_c(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride);
+#define aom_highbd_sad_skip_128x64 aom_highbd_sad_skip_128x64_c
+
+void aom_highbd_sad_skip_128x64x4d_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* const ref_ptr[],
+                                     int ref_stride,
+                                     uint32_t* sad_array);
+#define aom_highbd_sad_skip_128x64x4d aom_highbd_sad_skip_128x64x4d_c
+
+unsigned int aom_highbd_sad_skip_16x16_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_16x16 aom_highbd_sad_skip_16x16_c
+
+void aom_highbd_sad_skip_16x16x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_16x16x4d aom_highbd_sad_skip_16x16x4d_c
+
+unsigned int aom_highbd_sad_skip_16x32_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_16x32 aom_highbd_sad_skip_16x32_c
+
+void aom_highbd_sad_skip_16x32x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_16x32x4d aom_highbd_sad_skip_16x32x4d_c
+
+unsigned int aom_highbd_sad_skip_16x4_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_16x4 aom_highbd_sad_skip_16x4_c
+
+void aom_highbd_sad_skip_16x4x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_16x4x4d aom_highbd_sad_skip_16x4x4d_c
+
+unsigned int aom_highbd_sad_skip_16x64_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_16x64 aom_highbd_sad_skip_16x64_c
+
+void aom_highbd_sad_skip_16x64x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_16x64x4d aom_highbd_sad_skip_16x64x4d_c
+
+unsigned int aom_highbd_sad_skip_16x8_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_16x8 aom_highbd_sad_skip_16x8_c
+
+void aom_highbd_sad_skip_16x8x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_16x8x4d aom_highbd_sad_skip_16x8x4d_c
+
+unsigned int aom_highbd_sad_skip_32x16_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_32x16 aom_highbd_sad_skip_32x16_c
+
+void aom_highbd_sad_skip_32x16x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_32x16x4d aom_highbd_sad_skip_32x16x4d_c
+
+unsigned int aom_highbd_sad_skip_32x32_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_32x32 aom_highbd_sad_skip_32x32_c
+
+void aom_highbd_sad_skip_32x32x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_32x32x4d aom_highbd_sad_skip_32x32x4d_c
+
+unsigned int aom_highbd_sad_skip_32x64_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_32x64 aom_highbd_sad_skip_32x64_c
+
+void aom_highbd_sad_skip_32x64x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_32x64x4d aom_highbd_sad_skip_32x64x4d_c
+
+unsigned int aom_highbd_sad_skip_32x8_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_32x8 aom_highbd_sad_skip_32x8_c
+
+void aom_highbd_sad_skip_32x8x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_32x8x4d aom_highbd_sad_skip_32x8x4d_c
+
+unsigned int aom_highbd_sad_skip_4x16_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_4x16 aom_highbd_sad_skip_4x16_c
+
+void aom_highbd_sad_skip_4x16x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_4x16x4d aom_highbd_sad_skip_4x16x4d_c
+
+unsigned int aom_highbd_sad_skip_4x4_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+#define aom_highbd_sad_skip_4x4 aom_highbd_sad_skip_4x4_c
+
+void aom_highbd_sad_skip_4x4x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+#define aom_highbd_sad_skip_4x4x4d aom_highbd_sad_skip_4x4x4d_c
+
+unsigned int aom_highbd_sad_skip_4x8_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+#define aom_highbd_sad_skip_4x8 aom_highbd_sad_skip_4x8_c
+
+void aom_highbd_sad_skip_4x8x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+#define aom_highbd_sad_skip_4x8x4d aom_highbd_sad_skip_4x8x4d_c
+
+unsigned int aom_highbd_sad_skip_64x128_c(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride);
+#define aom_highbd_sad_skip_64x128 aom_highbd_sad_skip_64x128_c
+
+void aom_highbd_sad_skip_64x128x4d_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* const ref_ptr[],
+                                     int ref_stride,
+                                     uint32_t* sad_array);
+#define aom_highbd_sad_skip_64x128x4d aom_highbd_sad_skip_64x128x4d_c
+
+unsigned int aom_highbd_sad_skip_64x16_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_64x16 aom_highbd_sad_skip_64x16_c
+
+void aom_highbd_sad_skip_64x16x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_64x16x4d aom_highbd_sad_skip_64x16x4d_c
+
+unsigned int aom_highbd_sad_skip_64x32_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_64x32 aom_highbd_sad_skip_64x32_c
+
+void aom_highbd_sad_skip_64x32x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_64x32x4d aom_highbd_sad_skip_64x32x4d_c
+
+unsigned int aom_highbd_sad_skip_64x64_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_64x64 aom_highbd_sad_skip_64x64_c
+
+void aom_highbd_sad_skip_64x64x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_64x64x4d aom_highbd_sad_skip_64x64x4d_c
+
+unsigned int aom_highbd_sad_skip_8x16_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_8x16 aom_highbd_sad_skip_8x16_c
+
+void aom_highbd_sad_skip_8x16x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x16x4d aom_highbd_sad_skip_8x16x4d_c
+
+unsigned int aom_highbd_sad_skip_8x32_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_8x32 aom_highbd_sad_skip_8x32_c
+
+void aom_highbd_sad_skip_8x32x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x32x4d aom_highbd_sad_skip_8x32x4d_c
+
+unsigned int aom_highbd_sad_skip_8x4_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+#define aom_highbd_sad_skip_8x4 aom_highbd_sad_skip_8x4_c
+
+void aom_highbd_sad_skip_8x4x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x4x4d aom_highbd_sad_skip_8x4x4d_c
+
+unsigned int aom_highbd_sad_skip_8x8_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+#define aom_highbd_sad_skip_8x8 aom_highbd_sad_skip_8x8_c
+
+void aom_highbd_sad_skip_8x8x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x8x4d aom_highbd_sad_skip_8x8x4d_c
+
 void aom_highbd_smooth_h_predictor_16x16_c(uint16_t* dst,
                                            ptrdiff_t y_stride,
                                            const uint16_t* above,
@@ -11570,6 +11856,292 @@
                           int height);
 #define aom_sad8xh aom_sad8xh_c
 
+unsigned int aom_sad_skip_128x128_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride);
+#define aom_sad_skip_128x128 aom_sad_skip_128x128_c
+
+void aom_sad_skip_128x128x4d_c(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+#define aom_sad_skip_128x128x4d aom_sad_skip_128x128x4d_c
+
+unsigned int aom_sad_skip_128x64_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+#define aom_sad_skip_128x64 aom_sad_skip_128x64_c
+
+void aom_sad_skip_128x64x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+#define aom_sad_skip_128x64x4d aom_sad_skip_128x64x4d_c
+
+unsigned int aom_sad_skip_16x16_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_16x16 aom_sad_skip_16x16_c
+
+void aom_sad_skip_16x16x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_16x16x4d aom_sad_skip_16x16x4d_c
+
+unsigned int aom_sad_skip_16x32_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_16x32 aom_sad_skip_16x32_c
+
+void aom_sad_skip_16x32x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_16x32x4d aom_sad_skip_16x32x4d_c
+
+unsigned int aom_sad_skip_16x4_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_16x4 aom_sad_skip_16x4_c
+
+void aom_sad_skip_16x4x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_16x4x4d aom_sad_skip_16x4x4d_c
+
+unsigned int aom_sad_skip_16x64_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_16x64 aom_sad_skip_16x64_c
+
+void aom_sad_skip_16x64x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_16x64x4d aom_sad_skip_16x64x4d_c
+
+unsigned int aom_sad_skip_16x8_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_16x8 aom_sad_skip_16x8_c
+
+void aom_sad_skip_16x8x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_16x8x4d aom_sad_skip_16x8x4d_c
+
+unsigned int aom_sad_skip_32x16_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_32x16 aom_sad_skip_32x16_c
+
+void aom_sad_skip_32x16x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_32x16x4d aom_sad_skip_32x16x4d_c
+
+unsigned int aom_sad_skip_32x32_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_32x32 aom_sad_skip_32x32_c
+
+void aom_sad_skip_32x32x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_32x32x4d aom_sad_skip_32x32x4d_c
+
+unsigned int aom_sad_skip_32x64_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_32x64 aom_sad_skip_32x64_c
+
+void aom_sad_skip_32x64x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_32x64x4d aom_sad_skip_32x64x4d_c
+
+unsigned int aom_sad_skip_32x8_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_32x8 aom_sad_skip_32x8_c
+
+void aom_sad_skip_32x8x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_32x8x4d aom_sad_skip_32x8x4d_c
+
+unsigned int aom_sad_skip_4x16_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_4x16 aom_sad_skip_4x16_c
+
+void aom_sad_skip_4x16x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_4x16x4d aom_sad_skip_4x16x4d_c
+
+unsigned int aom_sad_skip_4x4_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+#define aom_sad_skip_4x4 aom_sad_skip_4x4_c
+
+void aom_sad_skip_4x4x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+#define aom_sad_skip_4x4x4d aom_sad_skip_4x4x4d_c
+
+unsigned int aom_sad_skip_4x8_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+#define aom_sad_skip_4x8 aom_sad_skip_4x8_c
+
+void aom_sad_skip_4x8x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+#define aom_sad_skip_4x8x4d aom_sad_skip_4x8x4d_c
+
+unsigned int aom_sad_skip_64x128_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+#define aom_sad_skip_64x128 aom_sad_skip_64x128_c
+
+void aom_sad_skip_64x128x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+#define aom_sad_skip_64x128x4d aom_sad_skip_64x128x4d_c
+
+unsigned int aom_sad_skip_64x16_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_64x16 aom_sad_skip_64x16_c
+
+void aom_sad_skip_64x16x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_64x16x4d aom_sad_skip_64x16x4d_c
+
+unsigned int aom_sad_skip_64x32_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_64x32 aom_sad_skip_64x32_c
+
+void aom_sad_skip_64x32x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_64x32x4d aom_sad_skip_64x32x4d_c
+
+unsigned int aom_sad_skip_64x64_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_64x64 aom_sad_skip_64x64_c
+
+void aom_sad_skip_64x64x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_64x64x4d aom_sad_skip_64x64x4d_c
+
+unsigned int aom_sad_skip_8x16_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_8x16 aom_sad_skip_8x16_c
+
+void aom_sad_skip_8x16x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_8x16x4d aom_sad_skip_8x16x4d_c
+
+unsigned int aom_sad_skip_8x32_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_8x32 aom_sad_skip_8x32_c
+
+void aom_sad_skip_8x32x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_8x32x4d aom_sad_skip_8x32x4d_c
+
+unsigned int aom_sad_skip_8x4_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+#define aom_sad_skip_8x4 aom_sad_skip_8x4_c
+
+void aom_sad_skip_8x4x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+#define aom_sad_skip_8x4x4d aom_sad_skip_8x4x4d_c
+
+unsigned int aom_sad_skip_8x8_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+#define aom_sad_skip_8x8 aom_sad_skip_8x8_c
+
+void aom_sad_skip_8x8x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+#define aom_sad_skip_8x8x4d aom_sad_skip_8x8x4d_c
+
 int aom_satd_c(const tran_low_t* coeff, int length);
 #define aom_satd aom_satd_c
 

diff --git a/third_party/libaom/source/config/linux/arm/config/av1_rtcd.h b/third_party/libaom/source/config/linux/arm/config/av1_rtcd.h
index eb684596..4864aaa7 100644
--- a/third_party/libaom/source/config/linux/arm/config/av1_rtcd.h
+++ b/third_party/libaom/source/config/linux/arm/config/av1_rtcd.h

@@ -599,6 +599,23 @@
                                int8_t* const coeff_contexts);
 #define av1_get_nz_map_contexts av1_get_nz_map_contexts_c
 
+void av1_highbd_apply_temporal_filter_c(
+    const struct yv12_buffer_config* ref_frame,
+    const struct macroblockd* mbd,
+    const BLOCK_SIZE block_size,
+    const int mb_row,
+    const int mb_col,
+    const int num_planes,
+    const double* noise_levels,
+    const MV* subblock_mvs,
+    const int* subblock_mses,
+    const int q_factor,
+    const int filter_strength,
+    const uint8_t* pred,
+    uint32_t* accum,
+    uint16_t* count);
+#define av1_highbd_apply_temporal_filter av1_highbd_apply_temporal_filter_c
+
 int64_t av1_highbd_block_error_c(const tran_low_t* coeff,
                                  const tran_low_t* dqcoeff,
                                  intptr_t block_size,

diff --git a/third_party/libaom/source/config/linux/arm64/config/aom_config.asm b/third_party/libaom/source/config/linux/arm64/config/aom_config.asm
index c72fccf..137f0909 100644
--- a/third_party/libaom/source/config/linux/arm64/config/aom_config.asm
+++ b/third_party/libaom/source/config/linux/arm64/config/aom_config.asm

@@ -43,6 +43,7 @@
 CONFIG_MULTITHREAD equ 1
 CONFIG_NN_V2 equ 0
 CONFIG_NORMAL_TILE_MODE equ 1
+CONFIG_OPTICAL_FLOW_API equ 0
 CONFIG_OS_SUPPORT equ 1
 CONFIG_PIC equ 0
 CONFIG_RD_DEBUG equ 0

diff --git a/third_party/libaom/source/config/linux/arm64/config/aom_config.h b/third_party/libaom/source/config/linux/arm64/config/aom_config.h
index c6d0bc38..927b683 100644
--- a/third_party/libaom/source/config/linux/arm64/config/aom_config.h
+++ b/third_party/libaom/source/config/linux/arm64/config/aom_config.h

@@ -45,6 +45,7 @@
 #define CONFIG_MULTITHREAD 1
 #define CONFIG_NN_V2 0
 #define CONFIG_NORMAL_TILE_MODE 1
+#define CONFIG_OPTICAL_FLOW_API 0
 #define CONFIG_OS_SUPPORT 1
 #define CONFIG_PIC 0
 #define CONFIG_RD_DEBUG 0

diff --git a/third_party/libaom/source/config/linux/arm64/config/aom_dsp_rtcd.h b/third_party/libaom/source/config/linux/arm64/config/aom_dsp_rtcd.h
index 0b7aca7..127d985 100644
--- a/third_party/libaom/source/config/linux/arm64/config/aom_dsp_rtcd.h
+++ b/third_party/libaom/source/config/linux/arm64/config/aom_dsp_rtcd.h

@@ -8789,6 +8789,292 @@
                             uint32_t* sad_array);
 #define aom_highbd_sad8x8x4d aom_highbd_sad8x8x4d_c
 
+unsigned int aom_highbd_sad_skip_128x128_c(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride);
+#define aom_highbd_sad_skip_128x128 aom_highbd_sad_skip_128x128_c
+
+void aom_highbd_sad_skip_128x128x4d_c(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* const ref_ptr[],
+                                      int ref_stride,
+                                      uint32_t* sad_array);
+#define aom_highbd_sad_skip_128x128x4d aom_highbd_sad_skip_128x128x4d_c
+
+unsigned int aom_highbd_sad_skip_128x64_c(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride);
+#define aom_highbd_sad_skip_128x64 aom_highbd_sad_skip_128x64_c
+
+void aom_highbd_sad_skip_128x64x4d_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* const ref_ptr[],
+                                     int ref_stride,
+                                     uint32_t* sad_array);
+#define aom_highbd_sad_skip_128x64x4d aom_highbd_sad_skip_128x64x4d_c
+
+unsigned int aom_highbd_sad_skip_16x16_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_16x16 aom_highbd_sad_skip_16x16_c
+
+void aom_highbd_sad_skip_16x16x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_16x16x4d aom_highbd_sad_skip_16x16x4d_c
+
+unsigned int aom_highbd_sad_skip_16x32_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_16x32 aom_highbd_sad_skip_16x32_c
+
+void aom_highbd_sad_skip_16x32x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_16x32x4d aom_highbd_sad_skip_16x32x4d_c
+
+unsigned int aom_highbd_sad_skip_16x4_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_16x4 aom_highbd_sad_skip_16x4_c
+
+void aom_highbd_sad_skip_16x4x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_16x4x4d aom_highbd_sad_skip_16x4x4d_c
+
+unsigned int aom_highbd_sad_skip_16x64_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_16x64 aom_highbd_sad_skip_16x64_c
+
+void aom_highbd_sad_skip_16x64x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_16x64x4d aom_highbd_sad_skip_16x64x4d_c
+
+unsigned int aom_highbd_sad_skip_16x8_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_16x8 aom_highbd_sad_skip_16x8_c
+
+void aom_highbd_sad_skip_16x8x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_16x8x4d aom_highbd_sad_skip_16x8x4d_c
+
+unsigned int aom_highbd_sad_skip_32x16_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_32x16 aom_highbd_sad_skip_32x16_c
+
+void aom_highbd_sad_skip_32x16x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_32x16x4d aom_highbd_sad_skip_32x16x4d_c
+
+unsigned int aom_highbd_sad_skip_32x32_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_32x32 aom_highbd_sad_skip_32x32_c
+
+void aom_highbd_sad_skip_32x32x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_32x32x4d aom_highbd_sad_skip_32x32x4d_c
+
+unsigned int aom_highbd_sad_skip_32x64_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_32x64 aom_highbd_sad_skip_32x64_c
+
+void aom_highbd_sad_skip_32x64x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_32x64x4d aom_highbd_sad_skip_32x64x4d_c
+
+unsigned int aom_highbd_sad_skip_32x8_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_32x8 aom_highbd_sad_skip_32x8_c
+
+void aom_highbd_sad_skip_32x8x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_32x8x4d aom_highbd_sad_skip_32x8x4d_c
+
+unsigned int aom_highbd_sad_skip_4x16_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_4x16 aom_highbd_sad_skip_4x16_c
+
+void aom_highbd_sad_skip_4x16x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_4x16x4d aom_highbd_sad_skip_4x16x4d_c
+
+unsigned int aom_highbd_sad_skip_4x4_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+#define aom_highbd_sad_skip_4x4 aom_highbd_sad_skip_4x4_c
+
+void aom_highbd_sad_skip_4x4x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+#define aom_highbd_sad_skip_4x4x4d aom_highbd_sad_skip_4x4x4d_c
+
+unsigned int aom_highbd_sad_skip_4x8_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+#define aom_highbd_sad_skip_4x8 aom_highbd_sad_skip_4x8_c
+
+void aom_highbd_sad_skip_4x8x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+#define aom_highbd_sad_skip_4x8x4d aom_highbd_sad_skip_4x8x4d_c
+
+unsigned int aom_highbd_sad_skip_64x128_c(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride);
+#define aom_highbd_sad_skip_64x128 aom_highbd_sad_skip_64x128_c
+
+void aom_highbd_sad_skip_64x128x4d_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* const ref_ptr[],
+                                     int ref_stride,
+                                     uint32_t* sad_array);
+#define aom_highbd_sad_skip_64x128x4d aom_highbd_sad_skip_64x128x4d_c
+
+unsigned int aom_highbd_sad_skip_64x16_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_64x16 aom_highbd_sad_skip_64x16_c
+
+void aom_highbd_sad_skip_64x16x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_64x16x4d aom_highbd_sad_skip_64x16x4d_c
+
+unsigned int aom_highbd_sad_skip_64x32_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_64x32 aom_highbd_sad_skip_64x32_c
+
+void aom_highbd_sad_skip_64x32x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_64x32x4d aom_highbd_sad_skip_64x32x4d_c
+
+unsigned int aom_highbd_sad_skip_64x64_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_64x64 aom_highbd_sad_skip_64x64_c
+
+void aom_highbd_sad_skip_64x64x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_64x64x4d aom_highbd_sad_skip_64x64x4d_c
+
+unsigned int aom_highbd_sad_skip_8x16_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_8x16 aom_highbd_sad_skip_8x16_c
+
+void aom_highbd_sad_skip_8x16x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x16x4d aom_highbd_sad_skip_8x16x4d_c
+
+unsigned int aom_highbd_sad_skip_8x32_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_8x32 aom_highbd_sad_skip_8x32_c
+
+void aom_highbd_sad_skip_8x32x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x32x4d aom_highbd_sad_skip_8x32x4d_c
+
+unsigned int aom_highbd_sad_skip_8x4_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+#define aom_highbd_sad_skip_8x4 aom_highbd_sad_skip_8x4_c
+
+void aom_highbd_sad_skip_8x4x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x4x4d aom_highbd_sad_skip_8x4x4d_c
+
+unsigned int aom_highbd_sad_skip_8x8_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+#define aom_highbd_sad_skip_8x8 aom_highbd_sad_skip_8x8_c
+
+void aom_highbd_sad_skip_8x8x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x8x4d aom_highbd_sad_skip_8x8x4d_c
+
 void aom_highbd_smooth_h_predictor_16x16_c(uint16_t* dst,
                                            ptrdiff_t y_stride,
                                            const uint16_t* above,
@@ -11884,6 +12170,292 @@
                           int height);
 #define aom_sad8xh aom_sad8xh_c
 
+unsigned int aom_sad_skip_128x128_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride);
+#define aom_sad_skip_128x128 aom_sad_skip_128x128_c
+
+void aom_sad_skip_128x128x4d_c(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+#define aom_sad_skip_128x128x4d aom_sad_skip_128x128x4d_c
+
+unsigned int aom_sad_skip_128x64_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+#define aom_sad_skip_128x64 aom_sad_skip_128x64_c
+
+void aom_sad_skip_128x64x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+#define aom_sad_skip_128x64x4d aom_sad_skip_128x64x4d_c
+
+unsigned int aom_sad_skip_16x16_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_16x16 aom_sad_skip_16x16_c
+
+void aom_sad_skip_16x16x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_16x16x4d aom_sad_skip_16x16x4d_c
+
+unsigned int aom_sad_skip_16x32_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_16x32 aom_sad_skip_16x32_c
+
+void aom_sad_skip_16x32x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_16x32x4d aom_sad_skip_16x32x4d_c
+
+unsigned int aom_sad_skip_16x4_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_16x4 aom_sad_skip_16x4_c
+
+void aom_sad_skip_16x4x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_16x4x4d aom_sad_skip_16x4x4d_c
+
+unsigned int aom_sad_skip_16x64_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_16x64 aom_sad_skip_16x64_c
+
+void aom_sad_skip_16x64x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_16x64x4d aom_sad_skip_16x64x4d_c
+
+unsigned int aom_sad_skip_16x8_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_16x8 aom_sad_skip_16x8_c
+
+void aom_sad_skip_16x8x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_16x8x4d aom_sad_skip_16x8x4d_c
+
+unsigned int aom_sad_skip_32x16_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_32x16 aom_sad_skip_32x16_c
+
+void aom_sad_skip_32x16x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_32x16x4d aom_sad_skip_32x16x4d_c
+
+unsigned int aom_sad_skip_32x32_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_32x32 aom_sad_skip_32x32_c
+
+void aom_sad_skip_32x32x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_32x32x4d aom_sad_skip_32x32x4d_c
+
+unsigned int aom_sad_skip_32x64_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_32x64 aom_sad_skip_32x64_c
+
+void aom_sad_skip_32x64x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_32x64x4d aom_sad_skip_32x64x4d_c
+
+unsigned int aom_sad_skip_32x8_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_32x8 aom_sad_skip_32x8_c
+
+void aom_sad_skip_32x8x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_32x8x4d aom_sad_skip_32x8x4d_c
+
+unsigned int aom_sad_skip_4x16_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_4x16 aom_sad_skip_4x16_c
+
+void aom_sad_skip_4x16x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_4x16x4d aom_sad_skip_4x16x4d_c
+
+unsigned int aom_sad_skip_4x4_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+#define aom_sad_skip_4x4 aom_sad_skip_4x4_c
+
+void aom_sad_skip_4x4x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+#define aom_sad_skip_4x4x4d aom_sad_skip_4x4x4d_c
+
+unsigned int aom_sad_skip_4x8_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+#define aom_sad_skip_4x8 aom_sad_skip_4x8_c
+
+void aom_sad_skip_4x8x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+#define aom_sad_skip_4x8x4d aom_sad_skip_4x8x4d_c
+
+unsigned int aom_sad_skip_64x128_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+#define aom_sad_skip_64x128 aom_sad_skip_64x128_c
+
+void aom_sad_skip_64x128x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+#define aom_sad_skip_64x128x4d aom_sad_skip_64x128x4d_c
+
+unsigned int aom_sad_skip_64x16_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_64x16 aom_sad_skip_64x16_c
+
+void aom_sad_skip_64x16x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_64x16x4d aom_sad_skip_64x16x4d_c
+
+unsigned int aom_sad_skip_64x32_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_64x32 aom_sad_skip_64x32_c
+
+void aom_sad_skip_64x32x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_64x32x4d aom_sad_skip_64x32x4d_c
+
+unsigned int aom_sad_skip_64x64_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_64x64 aom_sad_skip_64x64_c
+
+void aom_sad_skip_64x64x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_64x64x4d aom_sad_skip_64x64x4d_c
+
+unsigned int aom_sad_skip_8x16_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_8x16 aom_sad_skip_8x16_c
+
+void aom_sad_skip_8x16x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_8x16x4d aom_sad_skip_8x16x4d_c
+
+unsigned int aom_sad_skip_8x32_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_8x32 aom_sad_skip_8x32_c
+
+void aom_sad_skip_8x32x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_8x32x4d aom_sad_skip_8x32x4d_c
+
+unsigned int aom_sad_skip_8x4_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+#define aom_sad_skip_8x4 aom_sad_skip_8x4_c
+
+void aom_sad_skip_8x4x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+#define aom_sad_skip_8x4x4d aom_sad_skip_8x4x4d_c
+
+unsigned int aom_sad_skip_8x8_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+#define aom_sad_skip_8x8 aom_sad_skip_8x8_c
+
+void aom_sad_skip_8x8x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+#define aom_sad_skip_8x8x4d aom_sad_skip_8x8x4d_c
+
 int aom_satd_c(const tran_low_t* coeff, int length);
 int aom_satd_neon(const tran_low_t* coeff, int length);
 #define aom_satd aom_satd_neon

diff --git a/third_party/libaom/source/config/linux/arm64/config/av1_rtcd.h b/third_party/libaom/source/config/linux/arm64/config/av1_rtcd.h
index 60880ef..759f014e 100644
--- a/third_party/libaom/source/config/linux/arm64/config/av1_rtcd.h
+++ b/third_party/libaom/source/config/linux/arm64/config/av1_rtcd.h

@@ -848,6 +848,23 @@
                                   int8_t* const coeff_contexts);
 #define av1_get_nz_map_contexts av1_get_nz_map_contexts_neon
 
+void av1_highbd_apply_temporal_filter_c(
+    const struct yv12_buffer_config* ref_frame,
+    const struct macroblockd* mbd,
+    const BLOCK_SIZE block_size,
+    const int mb_row,
+    const int mb_col,
+    const int num_planes,
+    const double* noise_levels,
+    const MV* subblock_mvs,
+    const int* subblock_mses,
+    const int q_factor,
+    const int filter_strength,
+    const uint8_t* pred,
+    uint32_t* accum,
+    uint16_t* count);
+#define av1_highbd_apply_temporal_filter av1_highbd_apply_temporal_filter_c
+
 int64_t av1_highbd_block_error_c(const tran_low_t* coeff,
                                  const tran_low_t* dqcoeff,
                                  intptr_t block_size,

diff --git a/third_party/libaom/source/config/linux/generic/config/aom_config.asm b/third_party/libaom/source/config/linux/generic/config/aom_config.asm
index b1c6959e..f5e6edd 100644
--- a/third_party/libaom/source/config/linux/generic/config/aom_config.asm
+++ b/third_party/libaom/source/config/linux/generic/config/aom_config.asm

@@ -43,6 +43,7 @@
 CONFIG_MULTITHREAD equ 1
 CONFIG_NN_V2 equ 0
 CONFIG_NORMAL_TILE_MODE equ 1
+CONFIG_OPTICAL_FLOW_API equ 0
 CONFIG_OS_SUPPORT equ 1
 CONFIG_PIC equ 0
 CONFIG_RD_DEBUG equ 0

diff --git a/third_party/libaom/source/config/linux/generic/config/aom_config.h b/third_party/libaom/source/config/linux/generic/config/aom_config.h
index 9eee40b..84e78cc 100644
--- a/third_party/libaom/source/config/linux/generic/config/aom_config.h
+++ b/third_party/libaom/source/config/linux/generic/config/aom_config.h

@@ -45,6 +45,7 @@
 #define CONFIG_MULTITHREAD 1
 #define CONFIG_NN_V2 0
 #define CONFIG_NORMAL_TILE_MODE 1
+#define CONFIG_OPTICAL_FLOW_API 0
 #define CONFIG_OS_SUPPORT 1
 #define CONFIG_PIC 0
 #define CONFIG_RD_DEBUG 0

diff --git a/third_party/libaom/source/config/linux/generic/config/aom_dsp_rtcd.h b/third_party/libaom/source/config/linux/generic/config/aom_dsp_rtcd.h
index 1007eb1..8fbfdb12 100644
--- a/third_party/libaom/source/config/linux/generic/config/aom_dsp_rtcd.h
+++ b/third_party/libaom/source/config/linux/generic/config/aom_dsp_rtcd.h

@@ -8627,6 +8627,292 @@
                             uint32_t* sad_array);
 #define aom_highbd_sad8x8x4d aom_highbd_sad8x8x4d_c
 
+unsigned int aom_highbd_sad_skip_128x128_c(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride);
+#define aom_highbd_sad_skip_128x128 aom_highbd_sad_skip_128x128_c
+
+void aom_highbd_sad_skip_128x128x4d_c(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* const ref_ptr[],
+                                      int ref_stride,
+                                      uint32_t* sad_array);
+#define aom_highbd_sad_skip_128x128x4d aom_highbd_sad_skip_128x128x4d_c
+
+unsigned int aom_highbd_sad_skip_128x64_c(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride);
+#define aom_highbd_sad_skip_128x64 aom_highbd_sad_skip_128x64_c
+
+void aom_highbd_sad_skip_128x64x4d_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* const ref_ptr[],
+                                     int ref_stride,
+                                     uint32_t* sad_array);
+#define aom_highbd_sad_skip_128x64x4d aom_highbd_sad_skip_128x64x4d_c
+
+unsigned int aom_highbd_sad_skip_16x16_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_16x16 aom_highbd_sad_skip_16x16_c
+
+void aom_highbd_sad_skip_16x16x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_16x16x4d aom_highbd_sad_skip_16x16x4d_c
+
+unsigned int aom_highbd_sad_skip_16x32_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_16x32 aom_highbd_sad_skip_16x32_c
+
+void aom_highbd_sad_skip_16x32x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_16x32x4d aom_highbd_sad_skip_16x32x4d_c
+
+unsigned int aom_highbd_sad_skip_16x4_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_16x4 aom_highbd_sad_skip_16x4_c
+
+void aom_highbd_sad_skip_16x4x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_16x4x4d aom_highbd_sad_skip_16x4x4d_c
+
+unsigned int aom_highbd_sad_skip_16x64_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_16x64 aom_highbd_sad_skip_16x64_c
+
+void aom_highbd_sad_skip_16x64x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_16x64x4d aom_highbd_sad_skip_16x64x4d_c
+
+unsigned int aom_highbd_sad_skip_16x8_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_16x8 aom_highbd_sad_skip_16x8_c
+
+void aom_highbd_sad_skip_16x8x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_16x8x4d aom_highbd_sad_skip_16x8x4d_c
+
+unsigned int aom_highbd_sad_skip_32x16_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_32x16 aom_highbd_sad_skip_32x16_c
+
+void aom_highbd_sad_skip_32x16x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_32x16x4d aom_highbd_sad_skip_32x16x4d_c
+
+unsigned int aom_highbd_sad_skip_32x32_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_32x32 aom_highbd_sad_skip_32x32_c
+
+void aom_highbd_sad_skip_32x32x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_32x32x4d aom_highbd_sad_skip_32x32x4d_c
+
+unsigned int aom_highbd_sad_skip_32x64_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_32x64 aom_highbd_sad_skip_32x64_c
+
+void aom_highbd_sad_skip_32x64x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_32x64x4d aom_highbd_sad_skip_32x64x4d_c
+
+unsigned int aom_highbd_sad_skip_32x8_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_32x8 aom_highbd_sad_skip_32x8_c
+
+void aom_highbd_sad_skip_32x8x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_32x8x4d aom_highbd_sad_skip_32x8x4d_c
+
+unsigned int aom_highbd_sad_skip_4x16_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_4x16 aom_highbd_sad_skip_4x16_c
+
+void aom_highbd_sad_skip_4x16x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_4x16x4d aom_highbd_sad_skip_4x16x4d_c
+
+unsigned int aom_highbd_sad_skip_4x4_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+#define aom_highbd_sad_skip_4x4 aom_highbd_sad_skip_4x4_c
+
+void aom_highbd_sad_skip_4x4x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+#define aom_highbd_sad_skip_4x4x4d aom_highbd_sad_skip_4x4x4d_c
+
+unsigned int aom_highbd_sad_skip_4x8_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+#define aom_highbd_sad_skip_4x8 aom_highbd_sad_skip_4x8_c
+
+void aom_highbd_sad_skip_4x8x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+#define aom_highbd_sad_skip_4x8x4d aom_highbd_sad_skip_4x8x4d_c
+
+unsigned int aom_highbd_sad_skip_64x128_c(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride);
+#define aom_highbd_sad_skip_64x128 aom_highbd_sad_skip_64x128_c
+
+void aom_highbd_sad_skip_64x128x4d_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* const ref_ptr[],
+                                     int ref_stride,
+                                     uint32_t* sad_array);
+#define aom_highbd_sad_skip_64x128x4d aom_highbd_sad_skip_64x128x4d_c
+
+unsigned int aom_highbd_sad_skip_64x16_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_64x16 aom_highbd_sad_skip_64x16_c
+
+void aom_highbd_sad_skip_64x16x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_64x16x4d aom_highbd_sad_skip_64x16x4d_c
+
+unsigned int aom_highbd_sad_skip_64x32_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_64x32 aom_highbd_sad_skip_64x32_c
+
+void aom_highbd_sad_skip_64x32x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_64x32x4d aom_highbd_sad_skip_64x32x4d_c
+
+unsigned int aom_highbd_sad_skip_64x64_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_64x64 aom_highbd_sad_skip_64x64_c
+
+void aom_highbd_sad_skip_64x64x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_64x64x4d aom_highbd_sad_skip_64x64x4d_c
+
+unsigned int aom_highbd_sad_skip_8x16_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_8x16 aom_highbd_sad_skip_8x16_c
+
+void aom_highbd_sad_skip_8x16x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x16x4d aom_highbd_sad_skip_8x16x4d_c
+
+unsigned int aom_highbd_sad_skip_8x32_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_8x32 aom_highbd_sad_skip_8x32_c
+
+void aom_highbd_sad_skip_8x32x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x32x4d aom_highbd_sad_skip_8x32x4d_c
+
+unsigned int aom_highbd_sad_skip_8x4_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+#define aom_highbd_sad_skip_8x4 aom_highbd_sad_skip_8x4_c
+
+void aom_highbd_sad_skip_8x4x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x4x4d aom_highbd_sad_skip_8x4x4d_c
+
+unsigned int aom_highbd_sad_skip_8x8_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+#define aom_highbd_sad_skip_8x8 aom_highbd_sad_skip_8x8_c
+
+void aom_highbd_sad_skip_8x8x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x8x4d aom_highbd_sad_skip_8x8x4d_c
+
 void aom_highbd_smooth_h_predictor_16x16_c(uint16_t* dst,
                                            ptrdiff_t y_stride,
                                            const uint16_t* above,
@@ -11570,6 +11856,292 @@
                           int height);
 #define aom_sad8xh aom_sad8xh_c
 
+unsigned int aom_sad_skip_128x128_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride);
+#define aom_sad_skip_128x128 aom_sad_skip_128x128_c
+
+void aom_sad_skip_128x128x4d_c(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+#define aom_sad_skip_128x128x4d aom_sad_skip_128x128x4d_c
+
+unsigned int aom_sad_skip_128x64_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+#define aom_sad_skip_128x64 aom_sad_skip_128x64_c
+
+void aom_sad_skip_128x64x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+#define aom_sad_skip_128x64x4d aom_sad_skip_128x64x4d_c
+
+unsigned int aom_sad_skip_16x16_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_16x16 aom_sad_skip_16x16_c
+
+void aom_sad_skip_16x16x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_16x16x4d aom_sad_skip_16x16x4d_c
+
+unsigned int aom_sad_skip_16x32_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_16x32 aom_sad_skip_16x32_c
+
+void aom_sad_skip_16x32x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_16x32x4d aom_sad_skip_16x32x4d_c
+
+unsigned int aom_sad_skip_16x4_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_16x4 aom_sad_skip_16x4_c
+
+void aom_sad_skip_16x4x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_16x4x4d aom_sad_skip_16x4x4d_c
+
+unsigned int aom_sad_skip_16x64_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_16x64 aom_sad_skip_16x64_c
+
+void aom_sad_skip_16x64x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_16x64x4d aom_sad_skip_16x64x4d_c
+
+unsigned int aom_sad_skip_16x8_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_16x8 aom_sad_skip_16x8_c
+
+void aom_sad_skip_16x8x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_16x8x4d aom_sad_skip_16x8x4d_c
+
+unsigned int aom_sad_skip_32x16_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_32x16 aom_sad_skip_32x16_c
+
+void aom_sad_skip_32x16x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_32x16x4d aom_sad_skip_32x16x4d_c
+
+unsigned int aom_sad_skip_32x32_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_32x32 aom_sad_skip_32x32_c
+
+void aom_sad_skip_32x32x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_32x32x4d aom_sad_skip_32x32x4d_c
+
+unsigned int aom_sad_skip_32x64_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_32x64 aom_sad_skip_32x64_c
+
+void aom_sad_skip_32x64x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_32x64x4d aom_sad_skip_32x64x4d_c
+
+unsigned int aom_sad_skip_32x8_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_32x8 aom_sad_skip_32x8_c
+
+void aom_sad_skip_32x8x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_32x8x4d aom_sad_skip_32x8x4d_c
+
+unsigned int aom_sad_skip_4x16_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_4x16 aom_sad_skip_4x16_c
+
+void aom_sad_skip_4x16x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_4x16x4d aom_sad_skip_4x16x4d_c
+
+unsigned int aom_sad_skip_4x4_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+#define aom_sad_skip_4x4 aom_sad_skip_4x4_c
+
+void aom_sad_skip_4x4x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+#define aom_sad_skip_4x4x4d aom_sad_skip_4x4x4d_c
+
+unsigned int aom_sad_skip_4x8_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+#define aom_sad_skip_4x8 aom_sad_skip_4x8_c
+
+void aom_sad_skip_4x8x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+#define aom_sad_skip_4x8x4d aom_sad_skip_4x8x4d_c
+
+unsigned int aom_sad_skip_64x128_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+#define aom_sad_skip_64x128 aom_sad_skip_64x128_c
+
+void aom_sad_skip_64x128x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+#define aom_sad_skip_64x128x4d aom_sad_skip_64x128x4d_c
+
+unsigned int aom_sad_skip_64x16_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_64x16 aom_sad_skip_64x16_c
+
+void aom_sad_skip_64x16x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_64x16x4d aom_sad_skip_64x16x4d_c
+
+unsigned int aom_sad_skip_64x32_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_64x32 aom_sad_skip_64x32_c
+
+void aom_sad_skip_64x32x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_64x32x4d aom_sad_skip_64x32x4d_c
+
+unsigned int aom_sad_skip_64x64_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_64x64 aom_sad_skip_64x64_c
+
+void aom_sad_skip_64x64x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_64x64x4d aom_sad_skip_64x64x4d_c
+
+unsigned int aom_sad_skip_8x16_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_8x16 aom_sad_skip_8x16_c
+
+void aom_sad_skip_8x16x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_8x16x4d aom_sad_skip_8x16x4d_c
+
+unsigned int aom_sad_skip_8x32_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_8x32 aom_sad_skip_8x32_c
+
+void aom_sad_skip_8x32x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_8x32x4d aom_sad_skip_8x32x4d_c
+
+unsigned int aom_sad_skip_8x4_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+#define aom_sad_skip_8x4 aom_sad_skip_8x4_c
+
+void aom_sad_skip_8x4x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+#define aom_sad_skip_8x4x4d aom_sad_skip_8x4x4d_c
+
+unsigned int aom_sad_skip_8x8_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+#define aom_sad_skip_8x8 aom_sad_skip_8x8_c
+
+void aom_sad_skip_8x8x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+#define aom_sad_skip_8x8x4d aom_sad_skip_8x8x4d_c
+
 int aom_satd_c(const tran_low_t* coeff, int length);
 #define aom_satd aom_satd_c
 

diff --git a/third_party/libaom/source/config/linux/generic/config/av1_rtcd.h b/third_party/libaom/source/config/linux/generic/config/av1_rtcd.h
index a3e11504..f789783 100644
--- a/third_party/libaom/source/config/linux/generic/config/av1_rtcd.h
+++ b/third_party/libaom/source/config/linux/generic/config/av1_rtcd.h

@@ -599,6 +599,23 @@
                                int8_t* const coeff_contexts);
 #define av1_get_nz_map_contexts av1_get_nz_map_contexts_c
 
+void av1_highbd_apply_temporal_filter_c(
+    const struct yv12_buffer_config* ref_frame,
+    const struct macroblockd* mbd,
+    const BLOCK_SIZE block_size,
+    const int mb_row,
+    const int mb_col,
+    const int num_planes,
+    const double* noise_levels,
+    const MV* subblock_mvs,
+    const int* subblock_mses,
+    const int q_factor,
+    const int filter_strength,
+    const uint8_t* pred,
+    uint32_t* accum,
+    uint16_t* count);
+#define av1_highbd_apply_temporal_filter av1_highbd_apply_temporal_filter_c
+
 int64_t av1_highbd_block_error_c(const tran_low_t* coeff,
                                  const tran_low_t* dqcoeff,
                                  intptr_t block_size,

diff --git a/third_party/libaom/source/config/linux/ia32/config/aom_config.asm b/third_party/libaom/source/config/linux/ia32/config/aom_config.asm
index 725c90e..2ae437f856 100644
--- a/third_party/libaom/source/config/linux/ia32/config/aom_config.asm
+++ b/third_party/libaom/source/config/linux/ia32/config/aom_config.asm

@@ -33,6 +33,7 @@
 %define CONFIG_MULTITHREAD 1
 %define CONFIG_NN_V2 0
 %define CONFIG_NORMAL_TILE_MODE 1
+%define CONFIG_OPTICAL_FLOW_API 0
 %define CONFIG_OS_SUPPORT 1
 %define CONFIG_PIC 1
 %define CONFIG_RD_DEBUG 0

diff --git a/third_party/libaom/source/config/linux/ia32/config/aom_config.h b/third_party/libaom/source/config/linux/ia32/config/aom_config.h
index 72d50629..83216e1 100644
--- a/third_party/libaom/source/config/linux/ia32/config/aom_config.h
+++ b/third_party/libaom/source/config/linux/ia32/config/aom_config.h

@@ -45,6 +45,7 @@
 #define CONFIG_MULTITHREAD 1
 #define CONFIG_NN_V2 0
 #define CONFIG_NORMAL_TILE_MODE 1
+#define CONFIG_OPTICAL_FLOW_API 0
 #define CONFIG_OS_SUPPORT 1
 #define CONFIG_PIC 1
 #define CONFIG_RD_DEBUG 0

diff --git a/third_party/libaom/source/config/linux/ia32/config/aom_dsp_rtcd.h b/third_party/libaom/source/config/linux/ia32/config/aom_dsp_rtcd.h
index 16b01ee70..d500bf6 100644
--- a/third_party/libaom/source/config/linux/ia32/config/aom_dsp_rtcd.h
+++ b/third_party/libaom/source/config/linux/ia32/config/aom_dsp_rtcd.h

@@ -16090,6 +16090,663 @@
                                uint32_t* sad_array);
 #define aom_highbd_sad8x8x4d aom_highbd_sad8x8x4d_sse2
 
+unsigned int aom_highbd_sad_skip_128x128_c(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride);
+unsigned int aom_highbd_sad_skip_128x128_avx2(const uint8_t* src_ptr,
+                                              int src_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_128x128)(const uint8_t* src_ptr,
+                                                        int src_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride);
+
+void aom_highbd_sad_skip_128x128x4d_c(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* const ref_ptr[],
+                                      int ref_stride,
+                                      uint32_t* sad_array);
+void aom_highbd_sad_skip_128x128x4d_avx2(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* const ref_ptr[],
+                                         int ref_stride,
+                                         uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_128x128x4d)(
+    const uint8_t* src_ptr,
+    int src_stride,
+    const uint8_t* const ref_ptr[],
+    int ref_stride,
+    uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_128x64_c(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride);
+unsigned int aom_highbd_sad_skip_128x64_avx2(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_128x64)(const uint8_t* src_ptr,
+                                                       int src_stride,
+                                                       const uint8_t* ref_ptr,
+                                                       int ref_stride);
+
+void aom_highbd_sad_skip_128x64x4d_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* const ref_ptr[],
+                                     int ref_stride,
+                                     uint32_t* sad_array);
+void aom_highbd_sad_skip_128x64x4d_avx2(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* const ref_ptr[],
+                                        int ref_stride,
+                                        uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_128x64x4d)(
+    const uint8_t* src_ptr,
+    int src_stride,
+    const uint8_t* const ref_ptr[],
+    int ref_stride,
+    uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_16x16_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+unsigned int aom_highbd_sad_skip_16x16_sse2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+unsigned int aom_highbd_sad_skip_16x16_avx2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_16x16)(const uint8_t* src_ptr,
+                                                      int src_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride);
+
+void aom_highbd_sad_skip_16x16x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+void aom_highbd_sad_skip_16x16x4d_sse2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+void aom_highbd_sad_skip_16x16x4d_avx2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_16x16x4d)(const uint8_t* src_ptr,
+                                                 int src_stride,
+                                                 const uint8_t* const ref_ptr[],
+                                                 int ref_stride,
+                                                 uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_16x32_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+unsigned int aom_highbd_sad_skip_16x32_sse2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+unsigned int aom_highbd_sad_skip_16x32_avx2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_16x32)(const uint8_t* src_ptr,
+                                                      int src_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride);
+
+void aom_highbd_sad_skip_16x32x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+void aom_highbd_sad_skip_16x32x4d_sse2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+void aom_highbd_sad_skip_16x32x4d_avx2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_16x32x4d)(const uint8_t* src_ptr,
+                                                 int src_stride,
+                                                 const uint8_t* const ref_ptr[],
+                                                 int ref_stride,
+                                                 uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_16x4_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_16x4 aom_highbd_sad_skip_16x4_c
+
+void aom_highbd_sad_skip_16x4x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_16x4x4d aom_highbd_sad_skip_16x4x4d_c
+
+unsigned int aom_highbd_sad_skip_16x64_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+unsigned int aom_highbd_sad_skip_16x64_sse2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+unsigned int aom_highbd_sad_skip_16x64_avx2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_16x64)(const uint8_t* src_ptr,
+                                                      int src_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride);
+
+void aom_highbd_sad_skip_16x64x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+void aom_highbd_sad_skip_16x64x4d_sse2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+void aom_highbd_sad_skip_16x64x4d_avx2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_16x64x4d)(const uint8_t* src_ptr,
+                                                 int src_stride,
+                                                 const uint8_t* const ref_ptr[],
+                                                 int ref_stride,
+                                                 uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_16x8_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+unsigned int aom_highbd_sad_skip_16x8_sse2(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride);
+unsigned int aom_highbd_sad_skip_16x8_avx2(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_16x8)(const uint8_t* src_ptr,
+                                                     int src_stride,
+                                                     const uint8_t* ref_ptr,
+                                                     int ref_stride);
+
+void aom_highbd_sad_skip_16x8x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+void aom_highbd_sad_skip_16x8x4d_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* const ref_ptr[],
+                                      int ref_stride,
+                                      uint32_t* sad_array);
+void aom_highbd_sad_skip_16x8x4d_avx2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* const ref_ptr[],
+                                      int ref_stride,
+                                      uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_16x8x4d)(const uint8_t* src_ptr,
+                                                int src_stride,
+                                                const uint8_t* const ref_ptr[],
+                                                int ref_stride,
+                                                uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_32x16_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+unsigned int aom_highbd_sad_skip_32x16_sse2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+unsigned int aom_highbd_sad_skip_32x16_avx2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_32x16)(const uint8_t* src_ptr,
+                                                      int src_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride);
+
+void aom_highbd_sad_skip_32x16x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+void aom_highbd_sad_skip_32x16x4d_sse2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+void aom_highbd_sad_skip_32x16x4d_avx2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_32x16x4d)(const uint8_t* src_ptr,
+                                                 int src_stride,
+                                                 const uint8_t* const ref_ptr[],
+                                                 int ref_stride,
+                                                 uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_32x32_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+unsigned int aom_highbd_sad_skip_32x32_sse2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+unsigned int aom_highbd_sad_skip_32x32_avx2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_32x32)(const uint8_t* src_ptr,
+                                                      int src_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride);
+
+void aom_highbd_sad_skip_32x32x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+void aom_highbd_sad_skip_32x32x4d_sse2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+void aom_highbd_sad_skip_32x32x4d_avx2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_32x32x4d)(const uint8_t* src_ptr,
+                                                 int src_stride,
+                                                 const uint8_t* const ref_ptr[],
+                                                 int ref_stride,
+                                                 uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_32x64_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+unsigned int aom_highbd_sad_skip_32x64_sse2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+unsigned int aom_highbd_sad_skip_32x64_avx2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_32x64)(const uint8_t* src_ptr,
+                                                      int src_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride);
+
+void aom_highbd_sad_skip_32x64x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+void aom_highbd_sad_skip_32x64x4d_sse2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+void aom_highbd_sad_skip_32x64x4d_avx2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_32x64x4d)(const uint8_t* src_ptr,
+                                                 int src_stride,
+                                                 const uint8_t* const ref_ptr[],
+                                                 int ref_stride,
+                                                 uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_32x8_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+unsigned int aom_highbd_sad_skip_32x8_sse2(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride);
+unsigned int aom_highbd_sad_skip_32x8_avx2(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_32x8)(const uint8_t* src_ptr,
+                                                     int src_stride,
+                                                     const uint8_t* ref_ptr,
+                                                     int ref_stride);
+
+void aom_highbd_sad_skip_32x8x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+void aom_highbd_sad_skip_32x8x4d_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* const ref_ptr[],
+                                      int ref_stride,
+                                      uint32_t* sad_array);
+void aom_highbd_sad_skip_32x8x4d_avx2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* const ref_ptr[],
+                                      int ref_stride,
+                                      uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_32x8x4d)(const uint8_t* src_ptr,
+                                                int src_stride,
+                                                const uint8_t* const ref_ptr[],
+                                                int ref_stride,
+                                                uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_4x16_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+unsigned int aom_highbd_sad_skip_4x16_sse2(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride);
+#define aom_highbd_sad_skip_4x16 aom_highbd_sad_skip_4x16_sse2
+
+void aom_highbd_sad_skip_4x16x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+void aom_highbd_sad_skip_4x16x4d_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* const ref_ptr[],
+                                      int ref_stride,
+                                      uint32_t* sad_array);
+#define aom_highbd_sad_skip_4x16x4d aom_highbd_sad_skip_4x16x4d_sse2
+
+unsigned int aom_highbd_sad_skip_4x4_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+#define aom_highbd_sad_skip_4x4 aom_highbd_sad_skip_4x4_c
+
+void aom_highbd_sad_skip_4x4x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+#define aom_highbd_sad_skip_4x4x4d aom_highbd_sad_skip_4x4x4d_c
+
+unsigned int aom_highbd_sad_skip_4x8_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+unsigned int aom_highbd_sad_skip_4x8_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride);
+#define aom_highbd_sad_skip_4x8 aom_highbd_sad_skip_4x8_sse2
+
+void aom_highbd_sad_skip_4x8x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+void aom_highbd_sad_skip_4x8x4d_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* const ref_ptr[],
+                                     int ref_stride,
+                                     uint32_t* sad_array);
+#define aom_highbd_sad_skip_4x8x4d aom_highbd_sad_skip_4x8x4d_sse2
+
+unsigned int aom_highbd_sad_skip_64x128_c(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride);
+unsigned int aom_highbd_sad_skip_64x128_avx2(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_64x128)(const uint8_t* src_ptr,
+                                                       int src_stride,
+                                                       const uint8_t* ref_ptr,
+                                                       int ref_stride);
+
+void aom_highbd_sad_skip_64x128x4d_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* const ref_ptr[],
+                                     int ref_stride,
+                                     uint32_t* sad_array);
+void aom_highbd_sad_skip_64x128x4d_avx2(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* const ref_ptr[],
+                                        int ref_stride,
+                                        uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_64x128x4d)(
+    const uint8_t* src_ptr,
+    int src_stride,
+    const uint8_t* const ref_ptr[],
+    int ref_stride,
+    uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_64x16_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+unsigned int aom_highbd_sad_skip_64x16_sse2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+unsigned int aom_highbd_sad_skip_64x16_avx2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_64x16)(const uint8_t* src_ptr,
+                                                      int src_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride);
+
+void aom_highbd_sad_skip_64x16x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+void aom_highbd_sad_skip_64x16x4d_sse2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+void aom_highbd_sad_skip_64x16x4d_avx2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_64x16x4d)(const uint8_t* src_ptr,
+                                                 int src_stride,
+                                                 const uint8_t* const ref_ptr[],
+                                                 int ref_stride,
+                                                 uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_64x32_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+unsigned int aom_highbd_sad_skip_64x32_sse2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+unsigned int aom_highbd_sad_skip_64x32_avx2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_64x32)(const uint8_t* src_ptr,
+                                                      int src_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride);
+
+void aom_highbd_sad_skip_64x32x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+void aom_highbd_sad_skip_64x32x4d_sse2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+void aom_highbd_sad_skip_64x32x4d_avx2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_64x32x4d)(const uint8_t* src_ptr,
+                                                 int src_stride,
+                                                 const uint8_t* const ref_ptr[],
+                                                 int ref_stride,
+                                                 uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_64x64_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+unsigned int aom_highbd_sad_skip_64x64_sse2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+unsigned int aom_highbd_sad_skip_64x64_avx2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_64x64)(const uint8_t* src_ptr,
+                                                      int src_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride);
+
+void aom_highbd_sad_skip_64x64x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+void aom_highbd_sad_skip_64x64x4d_sse2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+void aom_highbd_sad_skip_64x64x4d_avx2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_64x64x4d)(const uint8_t* src_ptr,
+                                                 int src_stride,
+                                                 const uint8_t* const ref_ptr[],
+                                                 int ref_stride,
+                                                 uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_8x16_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+unsigned int aom_highbd_sad_skip_8x16_sse2(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride);
+#define aom_highbd_sad_skip_8x16 aom_highbd_sad_skip_8x16_sse2
+
+void aom_highbd_sad_skip_8x16x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+void aom_highbd_sad_skip_8x16x4d_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* const ref_ptr[],
+                                      int ref_stride,
+                                      uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x16x4d aom_highbd_sad_skip_8x16x4d_sse2
+
+unsigned int aom_highbd_sad_skip_8x32_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+unsigned int aom_highbd_sad_skip_8x32_sse2(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride);
+#define aom_highbd_sad_skip_8x32 aom_highbd_sad_skip_8x32_sse2
+
+void aom_highbd_sad_skip_8x32x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+void aom_highbd_sad_skip_8x32x4d_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* const ref_ptr[],
+                                      int ref_stride,
+                                      uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x32x4d aom_highbd_sad_skip_8x32x4d_sse2
+
+unsigned int aom_highbd_sad_skip_8x4_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+#define aom_highbd_sad_skip_8x4 aom_highbd_sad_skip_8x4_c
+
+void aom_highbd_sad_skip_8x4x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x4x4d aom_highbd_sad_skip_8x4x4d_c
+
+unsigned int aom_highbd_sad_skip_8x8_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+unsigned int aom_highbd_sad_skip_8x8_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride);
+#define aom_highbd_sad_skip_8x8 aom_highbd_sad_skip_8x8_sse2
+
+void aom_highbd_sad_skip_8x8x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+void aom_highbd_sad_skip_8x8x4d_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* const ref_ptr[],
+                                     int ref_stride,
+                                     uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x8x4d aom_highbd_sad_skip_8x8x4d_sse2
+
 void aom_highbd_smooth_h_predictor_16x16_c(uint16_t* dst,
                                            ptrdiff_t y_stride,
                                            const uint16_t* above,
@@ -22580,6 +23237,609 @@
                              int height);
 #define aom_sad8xh aom_sad8xh_sse2
 
+unsigned int aom_sad_skip_128x128_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride);
+unsigned int aom_sad_skip_128x128_sse2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+unsigned int aom_sad_skip_128x128_avx2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+RTCD_EXTERN unsigned int (*aom_sad_skip_128x128)(const uint8_t* src_ptr,
+                                                 int src_stride,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride);
+
+void aom_sad_skip_128x128x4d_c(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+void aom_sad_skip_128x128x4d_sse2(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+void aom_sad_skip_128x128x4d_avx2(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+RTCD_EXTERN void (*aom_sad_skip_128x128x4d)(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* const ref_ptr[],
+                                            int ref_stride,
+                                            uint32_t* sad_array);
+
+unsigned int aom_sad_skip_128x64_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int aom_sad_skip_128x64_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
+unsigned int aom_sad_skip_128x64_avx2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
+RTCD_EXTERN unsigned int (*aom_sad_skip_128x64)(const uint8_t* src_ptr,
+                                                int src_stride,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride);
+
+void aom_sad_skip_128x64x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void aom_sad_skip_128x64x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
+void aom_sad_skip_128x64x4d_avx2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
+RTCD_EXTERN void (*aom_sad_skip_128x64x4d)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* const ref_ptr[],
+                                           int ref_stride,
+                                           uint32_t* sad_array);
+
+unsigned int aom_sad_skip_16x16_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int aom_sad_skip_16x16_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+#define aom_sad_skip_16x16 aom_sad_skip_16x16_sse2
+
+void aom_sad_skip_16x16x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void aom_sad_skip_16x16x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+#define aom_sad_skip_16x16x4d aom_sad_skip_16x16x4d_sse2
+
+unsigned int aom_sad_skip_16x32_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int aom_sad_skip_16x32_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+#define aom_sad_skip_16x32 aom_sad_skip_16x32_sse2
+
+void aom_sad_skip_16x32x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void aom_sad_skip_16x32x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+#define aom_sad_skip_16x32x4d aom_sad_skip_16x32x4d_sse2
+
+unsigned int aom_sad_skip_16x4_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_16x4 aom_sad_skip_16x4_c
+
+void aom_sad_skip_16x4x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_16x4x4d aom_sad_skip_16x4x4d_c
+
+unsigned int aom_sad_skip_16x64_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int aom_sad_skip_16x64_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+#define aom_sad_skip_16x64 aom_sad_skip_16x64_sse2
+
+void aom_sad_skip_16x64x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void aom_sad_skip_16x64x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+#define aom_sad_skip_16x64x4d aom_sad_skip_16x64x4d_sse2
+
+unsigned int aom_sad_skip_16x8_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+unsigned int aom_sad_skip_16x8_sse2(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride);
+#define aom_sad_skip_16x8 aom_sad_skip_16x8_sse2
+
+void aom_sad_skip_16x8x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+void aom_sad_skip_16x8x4d_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+#define aom_sad_skip_16x8x4d aom_sad_skip_16x8x4d_sse2
+
+unsigned int aom_sad_skip_32x16_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int aom_sad_skip_32x16_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+unsigned int aom_sad_skip_32x16_avx2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+RTCD_EXTERN unsigned int (*aom_sad_skip_32x16)(const uint8_t* src_ptr,
+                                               int src_stride,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride);
+
+void aom_sad_skip_32x16x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void aom_sad_skip_32x16x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+void aom_sad_skip_32x16x4d_avx2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+RTCD_EXTERN void (*aom_sad_skip_32x16x4d)(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* const ref_ptr[],
+                                          int ref_stride,
+                                          uint32_t* sad_array);
+
+unsigned int aom_sad_skip_32x32_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int aom_sad_skip_32x32_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+unsigned int aom_sad_skip_32x32_avx2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+RTCD_EXTERN unsigned int (*aom_sad_skip_32x32)(const uint8_t* src_ptr,
+                                               int src_stride,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride);
+
+void aom_sad_skip_32x32x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void aom_sad_skip_32x32x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+void aom_sad_skip_32x32x4d_avx2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+RTCD_EXTERN void (*aom_sad_skip_32x32x4d)(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* const ref_ptr[],
+                                          int ref_stride,
+                                          uint32_t* sad_array);
+
+unsigned int aom_sad_skip_32x64_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int aom_sad_skip_32x64_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+unsigned int aom_sad_skip_32x64_avx2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+RTCD_EXTERN unsigned int (*aom_sad_skip_32x64)(const uint8_t* src_ptr,
+                                               int src_stride,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride);
+
+void aom_sad_skip_32x64x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void aom_sad_skip_32x64x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+void aom_sad_skip_32x64x4d_avx2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+RTCD_EXTERN void (*aom_sad_skip_32x64x4d)(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* const ref_ptr[],
+                                          int ref_stride,
+                                          uint32_t* sad_array);
+
+unsigned int aom_sad_skip_32x8_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+unsigned int aom_sad_skip_32x8_sse2(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride);
+#define aom_sad_skip_32x8 aom_sad_skip_32x8_sse2
+
+void aom_sad_skip_32x8x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+void aom_sad_skip_32x8x4d_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+void aom_sad_skip_32x8x4d_avx2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+RTCD_EXTERN void (*aom_sad_skip_32x8x4d)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* const ref_ptr[],
+                                         int ref_stride,
+                                         uint32_t* sad_array);
+
+unsigned int aom_sad_skip_4x16_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+unsigned int aom_sad_skip_4x16_sse2(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride);
+#define aom_sad_skip_4x16 aom_sad_skip_4x16_sse2
+
+void aom_sad_skip_4x16x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+void aom_sad_skip_4x16x4d_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+#define aom_sad_skip_4x16x4d aom_sad_skip_4x16x4d_sse2
+
+unsigned int aom_sad_skip_4x4_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+#define aom_sad_skip_4x4 aom_sad_skip_4x4_c
+
+void aom_sad_skip_4x4x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+#define aom_sad_skip_4x4x4d aom_sad_skip_4x4x4d_c
+
+unsigned int aom_sad_skip_4x8_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+unsigned int aom_sad_skip_4x8_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+#define aom_sad_skip_4x8 aom_sad_skip_4x8_sse2
+
+void aom_sad_skip_4x8x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+void aom_sad_skip_4x8x4d_sse2(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+#define aom_sad_skip_4x8x4d aom_sad_skip_4x8x4d_sse2
+
+unsigned int aom_sad_skip_64x128_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int aom_sad_skip_64x128_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
+unsigned int aom_sad_skip_64x128_avx2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
+RTCD_EXTERN unsigned int (*aom_sad_skip_64x128)(const uint8_t* src_ptr,
+                                                int src_stride,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride);
+
+void aom_sad_skip_64x128x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void aom_sad_skip_64x128x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
+void aom_sad_skip_64x128x4d_avx2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
+RTCD_EXTERN void (*aom_sad_skip_64x128x4d)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* const ref_ptr[],
+                                           int ref_stride,
+                                           uint32_t* sad_array);
+
+unsigned int aom_sad_skip_64x16_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int aom_sad_skip_64x16_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+#define aom_sad_skip_64x16 aom_sad_skip_64x16_sse2
+
+void aom_sad_skip_64x16x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void aom_sad_skip_64x16x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+void aom_sad_skip_64x16x4d_avx2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+RTCD_EXTERN void (*aom_sad_skip_64x16x4d)(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* const ref_ptr[],
+                                          int ref_stride,
+                                          uint32_t* sad_array);
+
+unsigned int aom_sad_skip_64x32_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int aom_sad_skip_64x32_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+unsigned int aom_sad_skip_64x32_avx2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+RTCD_EXTERN unsigned int (*aom_sad_skip_64x32)(const uint8_t* src_ptr,
+                                               int src_stride,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride);
+
+void aom_sad_skip_64x32x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void aom_sad_skip_64x32x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+void aom_sad_skip_64x32x4d_avx2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+RTCD_EXTERN void (*aom_sad_skip_64x32x4d)(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* const ref_ptr[],
+                                          int ref_stride,
+                                          uint32_t* sad_array);
+
+unsigned int aom_sad_skip_64x64_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int aom_sad_skip_64x64_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+unsigned int aom_sad_skip_64x64_avx2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+RTCD_EXTERN unsigned int (*aom_sad_skip_64x64)(const uint8_t* src_ptr,
+                                               int src_stride,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride);
+
+void aom_sad_skip_64x64x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void aom_sad_skip_64x64x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+void aom_sad_skip_64x64x4d_avx2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+RTCD_EXTERN void (*aom_sad_skip_64x64x4d)(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* const ref_ptr[],
+                                          int ref_stride,
+                                          uint32_t* sad_array);
+
+unsigned int aom_sad_skip_8x16_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+unsigned int aom_sad_skip_8x16_sse2(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride);
+#define aom_sad_skip_8x16 aom_sad_skip_8x16_sse2
+
+void aom_sad_skip_8x16x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+void aom_sad_skip_8x16x4d_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+#define aom_sad_skip_8x16x4d aom_sad_skip_8x16x4d_sse2
+
+unsigned int aom_sad_skip_8x32_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+unsigned int aom_sad_skip_8x32_sse2(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride);
+#define aom_sad_skip_8x32 aom_sad_skip_8x32_sse2
+
+void aom_sad_skip_8x32x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+void aom_sad_skip_8x32x4d_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+#define aom_sad_skip_8x32x4d aom_sad_skip_8x32x4d_sse2
+
+unsigned int aom_sad_skip_8x4_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+#define aom_sad_skip_8x4 aom_sad_skip_8x4_c
+
+void aom_sad_skip_8x4x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+#define aom_sad_skip_8x4x4d aom_sad_skip_8x4x4d_c
+
+unsigned int aom_sad_skip_8x8_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+unsigned int aom_sad_skip_8x8_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+#define aom_sad_skip_8x8 aom_sad_skip_8x8_sse2
+
+void aom_sad_skip_8x8x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+void aom_sad_skip_8x8x4d_sse2(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+#define aom_sad_skip_8x8x4d aom_sad_skip_8x8x4d_sse2
+
 int aom_satd_c(const tran_low_t* coeff, int length);
 int aom_satd_avx2(const tran_low_t* coeff, int length);
 RTCD_EXTERN int (*aom_satd)(const tran_low_t* coeff, int length);
@@ -27094,6 +28354,90 @@
   aom_highbd_sad64x64x4d = aom_highbd_sad64x64x4d_sse2;
   if (flags & HAS_AVX2)
     aom_highbd_sad64x64x4d = aom_highbd_sad64x64x4d_avx2;
+  aom_highbd_sad_skip_128x128 = aom_highbd_sad_skip_128x128_c;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_128x128 = aom_highbd_sad_skip_128x128_avx2;
+  aom_highbd_sad_skip_128x128x4d = aom_highbd_sad_skip_128x128x4d_c;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_128x128x4d = aom_highbd_sad_skip_128x128x4d_avx2;
+  aom_highbd_sad_skip_128x64 = aom_highbd_sad_skip_128x64_c;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_128x64 = aom_highbd_sad_skip_128x64_avx2;
+  aom_highbd_sad_skip_128x64x4d = aom_highbd_sad_skip_128x64x4d_c;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_128x64x4d = aom_highbd_sad_skip_128x64x4d_avx2;
+  aom_highbd_sad_skip_16x16 = aom_highbd_sad_skip_16x16_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_16x16 = aom_highbd_sad_skip_16x16_avx2;
+  aom_highbd_sad_skip_16x16x4d = aom_highbd_sad_skip_16x16x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_16x16x4d = aom_highbd_sad_skip_16x16x4d_avx2;
+  aom_highbd_sad_skip_16x32 = aom_highbd_sad_skip_16x32_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_16x32 = aom_highbd_sad_skip_16x32_avx2;
+  aom_highbd_sad_skip_16x32x4d = aom_highbd_sad_skip_16x32x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_16x32x4d = aom_highbd_sad_skip_16x32x4d_avx2;
+  aom_highbd_sad_skip_16x64 = aom_highbd_sad_skip_16x64_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_16x64 = aom_highbd_sad_skip_16x64_avx2;
+  aom_highbd_sad_skip_16x64x4d = aom_highbd_sad_skip_16x64x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_16x64x4d = aom_highbd_sad_skip_16x64x4d_avx2;
+  aom_highbd_sad_skip_16x8 = aom_highbd_sad_skip_16x8_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_16x8 = aom_highbd_sad_skip_16x8_avx2;
+  aom_highbd_sad_skip_16x8x4d = aom_highbd_sad_skip_16x8x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_16x8x4d = aom_highbd_sad_skip_16x8x4d_avx2;
+  aom_highbd_sad_skip_32x16 = aom_highbd_sad_skip_32x16_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_32x16 = aom_highbd_sad_skip_32x16_avx2;
+  aom_highbd_sad_skip_32x16x4d = aom_highbd_sad_skip_32x16x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_32x16x4d = aom_highbd_sad_skip_32x16x4d_avx2;
+  aom_highbd_sad_skip_32x32 = aom_highbd_sad_skip_32x32_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_32x32 = aom_highbd_sad_skip_32x32_avx2;
+  aom_highbd_sad_skip_32x32x4d = aom_highbd_sad_skip_32x32x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_32x32x4d = aom_highbd_sad_skip_32x32x4d_avx2;
+  aom_highbd_sad_skip_32x64 = aom_highbd_sad_skip_32x64_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_32x64 = aom_highbd_sad_skip_32x64_avx2;
+  aom_highbd_sad_skip_32x64x4d = aom_highbd_sad_skip_32x64x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_32x64x4d = aom_highbd_sad_skip_32x64x4d_avx2;
+  aom_highbd_sad_skip_32x8 = aom_highbd_sad_skip_32x8_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_32x8 = aom_highbd_sad_skip_32x8_avx2;
+  aom_highbd_sad_skip_32x8x4d = aom_highbd_sad_skip_32x8x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_32x8x4d = aom_highbd_sad_skip_32x8x4d_avx2;
+  aom_highbd_sad_skip_64x128 = aom_highbd_sad_skip_64x128_c;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_64x128 = aom_highbd_sad_skip_64x128_avx2;
+  aom_highbd_sad_skip_64x128x4d = aom_highbd_sad_skip_64x128x4d_c;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_64x128x4d = aom_highbd_sad_skip_64x128x4d_avx2;
+  aom_highbd_sad_skip_64x16 = aom_highbd_sad_skip_64x16_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_64x16 = aom_highbd_sad_skip_64x16_avx2;
+  aom_highbd_sad_skip_64x16x4d = aom_highbd_sad_skip_64x16x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_64x16x4d = aom_highbd_sad_skip_64x16x4d_avx2;
+  aom_highbd_sad_skip_64x32 = aom_highbd_sad_skip_64x32_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_64x32 = aom_highbd_sad_skip_64x32_avx2;
+  aom_highbd_sad_skip_64x32x4d = aom_highbd_sad_skip_64x32x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_64x32x4d = aom_highbd_sad_skip_64x32x4d_avx2;
+  aom_highbd_sad_skip_64x64 = aom_highbd_sad_skip_64x64_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_64x64 = aom_highbd_sad_skip_64x64_avx2;
+  aom_highbd_sad_skip_64x64x4d = aom_highbd_sad_skip_64x64x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_64x64x4d = aom_highbd_sad_skip_64x64x4d_avx2;
   aom_highbd_sse = aom_highbd_sse_c;
   if (flags & HAS_SSE4_1)
     aom_highbd_sse = aom_highbd_sse_sse4_1;
@@ -27832,6 +29176,60 @@
   aom_sad64x64x4d = aom_sad64x64x4d_sse2;
   if (flags & HAS_AVX2)
     aom_sad64x64x4d = aom_sad64x64x4d_avx2;
+  aom_sad_skip_128x128 = aom_sad_skip_128x128_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_128x128 = aom_sad_skip_128x128_avx2;
+  aom_sad_skip_128x128x4d = aom_sad_skip_128x128x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_128x128x4d = aom_sad_skip_128x128x4d_avx2;
+  aom_sad_skip_128x64 = aom_sad_skip_128x64_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_128x64 = aom_sad_skip_128x64_avx2;
+  aom_sad_skip_128x64x4d = aom_sad_skip_128x64x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_128x64x4d = aom_sad_skip_128x64x4d_avx2;
+  aom_sad_skip_32x16 = aom_sad_skip_32x16_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_32x16 = aom_sad_skip_32x16_avx2;
+  aom_sad_skip_32x16x4d = aom_sad_skip_32x16x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_32x16x4d = aom_sad_skip_32x16x4d_avx2;
+  aom_sad_skip_32x32 = aom_sad_skip_32x32_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_32x32 = aom_sad_skip_32x32_avx2;
+  aom_sad_skip_32x32x4d = aom_sad_skip_32x32x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_32x32x4d = aom_sad_skip_32x32x4d_avx2;
+  aom_sad_skip_32x64 = aom_sad_skip_32x64_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_32x64 = aom_sad_skip_32x64_avx2;
+  aom_sad_skip_32x64x4d = aom_sad_skip_32x64x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_32x64x4d = aom_sad_skip_32x64x4d_avx2;
+  aom_sad_skip_32x8x4d = aom_sad_skip_32x8x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_32x8x4d = aom_sad_skip_32x8x4d_avx2;
+  aom_sad_skip_64x128 = aom_sad_skip_64x128_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_64x128 = aom_sad_skip_64x128_avx2;
+  aom_sad_skip_64x128x4d = aom_sad_skip_64x128x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_64x128x4d = aom_sad_skip_64x128x4d_avx2;
+  aom_sad_skip_64x16x4d = aom_sad_skip_64x16x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_64x16x4d = aom_sad_skip_64x16x4d_avx2;
+  aom_sad_skip_64x32 = aom_sad_skip_64x32_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_64x32 = aom_sad_skip_64x32_avx2;
+  aom_sad_skip_64x32x4d = aom_sad_skip_64x32x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_64x32x4d = aom_sad_skip_64x32x4d_avx2;
+  aom_sad_skip_64x64 = aom_sad_skip_64x64_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_64x64 = aom_sad_skip_64x64_avx2;
+  aom_sad_skip_64x64x4d = aom_sad_skip_64x64x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_64x64x4d = aom_sad_skip_64x64x4d_avx2;
   aom_satd = aom_satd_c;
   if (flags & HAS_AVX2)
     aom_satd = aom_satd_avx2;

diff --git a/third_party/libaom/source/config/linux/ia32/config/av1_rtcd.h b/third_party/libaom/source/config/linux/ia32/config/av1_rtcd.h
index 934c69a..90f686a11 100644
--- a/third_party/libaom/source/config/linux/ia32/config/av1_rtcd.h
+++ b/third_party/libaom/source/config/linux/ia32/config/av1_rtcd.h

@@ -1439,6 +1439,38 @@
                                   int8_t* const coeff_contexts);
 #define av1_get_nz_map_contexts av1_get_nz_map_contexts_sse2
 
+void av1_highbd_apply_temporal_filter_c(
+    const struct yv12_buffer_config* ref_frame,
+    const struct macroblockd* mbd,
+    const BLOCK_SIZE block_size,
+    const int mb_row,
+    const int mb_col,
+    const int num_planes,
+    const double* noise_levels,
+    const MV* subblock_mvs,
+    const int* subblock_mses,
+    const int q_factor,
+    const int filter_strength,
+    const uint8_t* pred,
+    uint32_t* accum,
+    uint16_t* count);
+void av1_highbd_apply_temporal_filter_sse2(
+    const struct yv12_buffer_config* ref_frame,
+    const struct macroblockd* mbd,
+    const BLOCK_SIZE block_size,
+    const int mb_row,
+    const int mb_col,
+    const int num_planes,
+    const double* noise_levels,
+    const MV* subblock_mvs,
+    const int* subblock_mses,
+    const int q_factor,
+    const int filter_strength,
+    const uint8_t* pred,
+    uint32_t* accum,
+    uint16_t* count);
+#define av1_highbd_apply_temporal_filter av1_highbd_apply_temporal_filter_sse2
+
 int64_t av1_highbd_block_error_c(const tran_low_t* coeff,
                                  const tran_low_t* dqcoeff,
                                  intptr_t block_size,

diff --git a/third_party/libaom/source/config/linux/x64/config/aom_config.asm b/third_party/libaom/source/config/linux/x64/config/aom_config.asm
index 86fc4d1..25707d8b 100644
--- a/third_party/libaom/source/config/linux/x64/config/aom_config.asm
+++ b/third_party/libaom/source/config/linux/x64/config/aom_config.asm

@@ -33,6 +33,7 @@
 %define CONFIG_MULTITHREAD 1
 %define CONFIG_NN_V2 0
 %define CONFIG_NORMAL_TILE_MODE 1
+%define CONFIG_OPTICAL_FLOW_API 0
 %define CONFIG_OS_SUPPORT 1
 %define CONFIG_PIC 0
 %define CONFIG_RD_DEBUG 0

diff --git a/third_party/libaom/source/config/linux/x64/config/aom_config.h b/third_party/libaom/source/config/linux/x64/config/aom_config.h
index 125dc6ea..bf2e313b 100644
--- a/third_party/libaom/source/config/linux/x64/config/aom_config.h
+++ b/third_party/libaom/source/config/linux/x64/config/aom_config.h

@@ -45,6 +45,7 @@
 #define CONFIG_MULTITHREAD 1
 #define CONFIG_NN_V2 0
 #define CONFIG_NORMAL_TILE_MODE 1
+#define CONFIG_OPTICAL_FLOW_API 0
 #define CONFIG_OS_SUPPORT 1
 #define CONFIG_PIC 0
 #define CONFIG_RD_DEBUG 0

diff --git a/third_party/libaom/source/config/linux/x64/config/aom_dsp_rtcd.h b/third_party/libaom/source/config/linux/x64/config/aom_dsp_rtcd.h
index c199cbb..ca0b8a1 100644
--- a/third_party/libaom/source/config/linux/x64/config/aom_dsp_rtcd.h
+++ b/third_party/libaom/source/config/linux/x64/config/aom_dsp_rtcd.h

@@ -16093,6 +16093,663 @@
                                uint32_t* sad_array);
 #define aom_highbd_sad8x8x4d aom_highbd_sad8x8x4d_sse2
 
+unsigned int aom_highbd_sad_skip_128x128_c(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride);
+unsigned int aom_highbd_sad_skip_128x128_avx2(const uint8_t* src_ptr,
+                                              int src_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_128x128)(const uint8_t* src_ptr,
+                                                        int src_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride);
+
+void aom_highbd_sad_skip_128x128x4d_c(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* const ref_ptr[],
+                                      int ref_stride,
+                                      uint32_t* sad_array);
+void aom_highbd_sad_skip_128x128x4d_avx2(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* const ref_ptr[],
+                                         int ref_stride,
+                                         uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_128x128x4d)(
+    const uint8_t* src_ptr,
+    int src_stride,
+    const uint8_t* const ref_ptr[],
+    int ref_stride,
+    uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_128x64_c(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride);
+unsigned int aom_highbd_sad_skip_128x64_avx2(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_128x64)(const uint8_t* src_ptr,
+                                                       int src_stride,
+                                                       const uint8_t* ref_ptr,
+                                                       int ref_stride);
+
+void aom_highbd_sad_skip_128x64x4d_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* const ref_ptr[],
+                                     int ref_stride,
+                                     uint32_t* sad_array);
+void aom_highbd_sad_skip_128x64x4d_avx2(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* const ref_ptr[],
+                                        int ref_stride,
+                                        uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_128x64x4d)(
+    const uint8_t* src_ptr,
+    int src_stride,
+    const uint8_t* const ref_ptr[],
+    int ref_stride,
+    uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_16x16_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+unsigned int aom_highbd_sad_skip_16x16_sse2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+unsigned int aom_highbd_sad_skip_16x16_avx2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_16x16)(const uint8_t* src_ptr,
+                                                      int src_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride);
+
+void aom_highbd_sad_skip_16x16x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+void aom_highbd_sad_skip_16x16x4d_sse2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+void aom_highbd_sad_skip_16x16x4d_avx2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_16x16x4d)(const uint8_t* src_ptr,
+                                                 int src_stride,
+                                                 const uint8_t* const ref_ptr[],
+                                                 int ref_stride,
+                                                 uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_16x32_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+unsigned int aom_highbd_sad_skip_16x32_sse2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+unsigned int aom_highbd_sad_skip_16x32_avx2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_16x32)(const uint8_t* src_ptr,
+                                                      int src_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride);
+
+void aom_highbd_sad_skip_16x32x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+void aom_highbd_sad_skip_16x32x4d_sse2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+void aom_highbd_sad_skip_16x32x4d_avx2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_16x32x4d)(const uint8_t* src_ptr,
+                                                 int src_stride,
+                                                 const uint8_t* const ref_ptr[],
+                                                 int ref_stride,
+                                                 uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_16x4_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_16x4 aom_highbd_sad_skip_16x4_c
+
+void aom_highbd_sad_skip_16x4x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_16x4x4d aom_highbd_sad_skip_16x4x4d_c
+
+unsigned int aom_highbd_sad_skip_16x64_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+unsigned int aom_highbd_sad_skip_16x64_sse2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+unsigned int aom_highbd_sad_skip_16x64_avx2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_16x64)(const uint8_t* src_ptr,
+                                                      int src_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride);
+
+void aom_highbd_sad_skip_16x64x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+void aom_highbd_sad_skip_16x64x4d_sse2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+void aom_highbd_sad_skip_16x64x4d_avx2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_16x64x4d)(const uint8_t* src_ptr,
+                                                 int src_stride,
+                                                 const uint8_t* const ref_ptr[],
+                                                 int ref_stride,
+                                                 uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_16x8_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+unsigned int aom_highbd_sad_skip_16x8_sse2(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride);
+unsigned int aom_highbd_sad_skip_16x8_avx2(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_16x8)(const uint8_t* src_ptr,
+                                                     int src_stride,
+                                                     const uint8_t* ref_ptr,
+                                                     int ref_stride);
+
+void aom_highbd_sad_skip_16x8x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+void aom_highbd_sad_skip_16x8x4d_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* const ref_ptr[],
+                                      int ref_stride,
+                                      uint32_t* sad_array);
+void aom_highbd_sad_skip_16x8x4d_avx2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* const ref_ptr[],
+                                      int ref_stride,
+                                      uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_16x8x4d)(const uint8_t* src_ptr,
+                                                int src_stride,
+                                                const uint8_t* const ref_ptr[],
+                                                int ref_stride,
+                                                uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_32x16_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+unsigned int aom_highbd_sad_skip_32x16_sse2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+unsigned int aom_highbd_sad_skip_32x16_avx2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_32x16)(const uint8_t* src_ptr,
+                                                      int src_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride);
+
+void aom_highbd_sad_skip_32x16x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+void aom_highbd_sad_skip_32x16x4d_sse2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+void aom_highbd_sad_skip_32x16x4d_avx2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_32x16x4d)(const uint8_t* src_ptr,
+                                                 int src_stride,
+                                                 const uint8_t* const ref_ptr[],
+                                                 int ref_stride,
+                                                 uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_32x32_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+unsigned int aom_highbd_sad_skip_32x32_sse2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+unsigned int aom_highbd_sad_skip_32x32_avx2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_32x32)(const uint8_t* src_ptr,
+                                                      int src_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride);
+
+void aom_highbd_sad_skip_32x32x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+void aom_highbd_sad_skip_32x32x4d_sse2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+void aom_highbd_sad_skip_32x32x4d_avx2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_32x32x4d)(const uint8_t* src_ptr,
+                                                 int src_stride,
+                                                 const uint8_t* const ref_ptr[],
+                                                 int ref_stride,
+                                                 uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_32x64_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+unsigned int aom_highbd_sad_skip_32x64_sse2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+unsigned int aom_highbd_sad_skip_32x64_avx2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_32x64)(const uint8_t* src_ptr,
+                                                      int src_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride);
+
+void aom_highbd_sad_skip_32x64x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+void aom_highbd_sad_skip_32x64x4d_sse2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+void aom_highbd_sad_skip_32x64x4d_avx2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_32x64x4d)(const uint8_t* src_ptr,
+                                                 int src_stride,
+                                                 const uint8_t* const ref_ptr[],
+                                                 int ref_stride,
+                                                 uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_32x8_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+unsigned int aom_highbd_sad_skip_32x8_sse2(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride);
+unsigned int aom_highbd_sad_skip_32x8_avx2(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_32x8)(const uint8_t* src_ptr,
+                                                     int src_stride,
+                                                     const uint8_t* ref_ptr,
+                                                     int ref_stride);
+
+void aom_highbd_sad_skip_32x8x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+void aom_highbd_sad_skip_32x8x4d_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* const ref_ptr[],
+                                      int ref_stride,
+                                      uint32_t* sad_array);
+void aom_highbd_sad_skip_32x8x4d_avx2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* const ref_ptr[],
+                                      int ref_stride,
+                                      uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_32x8x4d)(const uint8_t* src_ptr,
+                                                int src_stride,
+                                                const uint8_t* const ref_ptr[],
+                                                int ref_stride,
+                                                uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_4x16_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+unsigned int aom_highbd_sad_skip_4x16_sse2(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride);
+#define aom_highbd_sad_skip_4x16 aom_highbd_sad_skip_4x16_sse2
+
+void aom_highbd_sad_skip_4x16x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+void aom_highbd_sad_skip_4x16x4d_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* const ref_ptr[],
+                                      int ref_stride,
+                                      uint32_t* sad_array);
+#define aom_highbd_sad_skip_4x16x4d aom_highbd_sad_skip_4x16x4d_sse2
+
+unsigned int aom_highbd_sad_skip_4x4_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+#define aom_highbd_sad_skip_4x4 aom_highbd_sad_skip_4x4_c
+
+void aom_highbd_sad_skip_4x4x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+#define aom_highbd_sad_skip_4x4x4d aom_highbd_sad_skip_4x4x4d_c
+
+unsigned int aom_highbd_sad_skip_4x8_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+unsigned int aom_highbd_sad_skip_4x8_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride);
+#define aom_highbd_sad_skip_4x8 aom_highbd_sad_skip_4x8_sse2
+
+void aom_highbd_sad_skip_4x8x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+void aom_highbd_sad_skip_4x8x4d_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* const ref_ptr[],
+                                     int ref_stride,
+                                     uint32_t* sad_array);
+#define aom_highbd_sad_skip_4x8x4d aom_highbd_sad_skip_4x8x4d_sse2
+
+unsigned int aom_highbd_sad_skip_64x128_c(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride);
+unsigned int aom_highbd_sad_skip_64x128_avx2(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_64x128)(const uint8_t* src_ptr,
+                                                       int src_stride,
+                                                       const uint8_t* ref_ptr,
+                                                       int ref_stride);
+
+void aom_highbd_sad_skip_64x128x4d_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* const ref_ptr[],
+                                     int ref_stride,
+                                     uint32_t* sad_array);
+void aom_highbd_sad_skip_64x128x4d_avx2(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* const ref_ptr[],
+                                        int ref_stride,
+                                        uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_64x128x4d)(
+    const uint8_t* src_ptr,
+    int src_stride,
+    const uint8_t* const ref_ptr[],
+    int ref_stride,
+    uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_64x16_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+unsigned int aom_highbd_sad_skip_64x16_sse2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+unsigned int aom_highbd_sad_skip_64x16_avx2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_64x16)(const uint8_t* src_ptr,
+                                                      int src_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride);
+
+void aom_highbd_sad_skip_64x16x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+void aom_highbd_sad_skip_64x16x4d_sse2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+void aom_highbd_sad_skip_64x16x4d_avx2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_64x16x4d)(const uint8_t* src_ptr,
+                                                 int src_stride,
+                                                 const uint8_t* const ref_ptr[],
+                                                 int ref_stride,
+                                                 uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_64x32_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+unsigned int aom_highbd_sad_skip_64x32_sse2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+unsigned int aom_highbd_sad_skip_64x32_avx2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_64x32)(const uint8_t* src_ptr,
+                                                      int src_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride);
+
+void aom_highbd_sad_skip_64x32x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+void aom_highbd_sad_skip_64x32x4d_sse2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+void aom_highbd_sad_skip_64x32x4d_avx2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_64x32x4d)(const uint8_t* src_ptr,
+                                                 int src_stride,
+                                                 const uint8_t* const ref_ptr[],
+                                                 int ref_stride,
+                                                 uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_64x64_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+unsigned int aom_highbd_sad_skip_64x64_sse2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+unsigned int aom_highbd_sad_skip_64x64_avx2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_64x64)(const uint8_t* src_ptr,
+                                                      int src_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride);
+
+void aom_highbd_sad_skip_64x64x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+void aom_highbd_sad_skip_64x64x4d_sse2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+void aom_highbd_sad_skip_64x64x4d_avx2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_64x64x4d)(const uint8_t* src_ptr,
+                                                 int src_stride,
+                                                 const uint8_t* const ref_ptr[],
+                                                 int ref_stride,
+                                                 uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_8x16_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+unsigned int aom_highbd_sad_skip_8x16_sse2(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride);
+#define aom_highbd_sad_skip_8x16 aom_highbd_sad_skip_8x16_sse2
+
+void aom_highbd_sad_skip_8x16x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+void aom_highbd_sad_skip_8x16x4d_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* const ref_ptr[],
+                                      int ref_stride,
+                                      uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x16x4d aom_highbd_sad_skip_8x16x4d_sse2
+
+unsigned int aom_highbd_sad_skip_8x32_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+unsigned int aom_highbd_sad_skip_8x32_sse2(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride);
+#define aom_highbd_sad_skip_8x32 aom_highbd_sad_skip_8x32_sse2
+
+void aom_highbd_sad_skip_8x32x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+void aom_highbd_sad_skip_8x32x4d_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* const ref_ptr[],
+                                      int ref_stride,
+                                      uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x32x4d aom_highbd_sad_skip_8x32x4d_sse2
+
+unsigned int aom_highbd_sad_skip_8x4_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+#define aom_highbd_sad_skip_8x4 aom_highbd_sad_skip_8x4_c
+
+void aom_highbd_sad_skip_8x4x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x4x4d aom_highbd_sad_skip_8x4x4d_c
+
+unsigned int aom_highbd_sad_skip_8x8_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+unsigned int aom_highbd_sad_skip_8x8_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride);
+#define aom_highbd_sad_skip_8x8 aom_highbd_sad_skip_8x8_sse2
+
+void aom_highbd_sad_skip_8x8x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+void aom_highbd_sad_skip_8x8x4d_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* const ref_ptr[],
+                                     int ref_stride,
+                                     uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x8x4d aom_highbd_sad_skip_8x8x4d_sse2
+
 void aom_highbd_smooth_h_predictor_16x16_c(uint16_t* dst,
                                            ptrdiff_t y_stride,
                                            const uint16_t* above,
@@ -22607,6 +23264,609 @@
                              int height);
 #define aom_sad8xh aom_sad8xh_sse2
 
+unsigned int aom_sad_skip_128x128_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride);
+unsigned int aom_sad_skip_128x128_sse2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+unsigned int aom_sad_skip_128x128_avx2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+RTCD_EXTERN unsigned int (*aom_sad_skip_128x128)(const uint8_t* src_ptr,
+                                                 int src_stride,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride);
+
+void aom_sad_skip_128x128x4d_c(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+void aom_sad_skip_128x128x4d_sse2(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+void aom_sad_skip_128x128x4d_avx2(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+RTCD_EXTERN void (*aom_sad_skip_128x128x4d)(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* const ref_ptr[],
+                                            int ref_stride,
+                                            uint32_t* sad_array);
+
+unsigned int aom_sad_skip_128x64_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int aom_sad_skip_128x64_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
+unsigned int aom_sad_skip_128x64_avx2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
+RTCD_EXTERN unsigned int (*aom_sad_skip_128x64)(const uint8_t* src_ptr,
+                                                int src_stride,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride);
+
+void aom_sad_skip_128x64x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void aom_sad_skip_128x64x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
+void aom_sad_skip_128x64x4d_avx2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
+RTCD_EXTERN void (*aom_sad_skip_128x64x4d)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* const ref_ptr[],
+                                           int ref_stride,
+                                           uint32_t* sad_array);
+
+unsigned int aom_sad_skip_16x16_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int aom_sad_skip_16x16_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+#define aom_sad_skip_16x16 aom_sad_skip_16x16_sse2
+
+void aom_sad_skip_16x16x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void aom_sad_skip_16x16x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+#define aom_sad_skip_16x16x4d aom_sad_skip_16x16x4d_sse2
+
+unsigned int aom_sad_skip_16x32_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int aom_sad_skip_16x32_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+#define aom_sad_skip_16x32 aom_sad_skip_16x32_sse2
+
+void aom_sad_skip_16x32x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void aom_sad_skip_16x32x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+#define aom_sad_skip_16x32x4d aom_sad_skip_16x32x4d_sse2
+
+unsigned int aom_sad_skip_16x4_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_16x4 aom_sad_skip_16x4_c
+
+void aom_sad_skip_16x4x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_16x4x4d aom_sad_skip_16x4x4d_c
+
+unsigned int aom_sad_skip_16x64_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int aom_sad_skip_16x64_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+#define aom_sad_skip_16x64 aom_sad_skip_16x64_sse2
+
+void aom_sad_skip_16x64x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void aom_sad_skip_16x64x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+#define aom_sad_skip_16x64x4d aom_sad_skip_16x64x4d_sse2
+
+unsigned int aom_sad_skip_16x8_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+unsigned int aom_sad_skip_16x8_sse2(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride);
+#define aom_sad_skip_16x8 aom_sad_skip_16x8_sse2
+
+void aom_sad_skip_16x8x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+void aom_sad_skip_16x8x4d_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+#define aom_sad_skip_16x8x4d aom_sad_skip_16x8x4d_sse2
+
+unsigned int aom_sad_skip_32x16_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int aom_sad_skip_32x16_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+unsigned int aom_sad_skip_32x16_avx2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+RTCD_EXTERN unsigned int (*aom_sad_skip_32x16)(const uint8_t* src_ptr,
+                                               int src_stride,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride);
+
+void aom_sad_skip_32x16x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void aom_sad_skip_32x16x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+void aom_sad_skip_32x16x4d_avx2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+RTCD_EXTERN void (*aom_sad_skip_32x16x4d)(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* const ref_ptr[],
+                                          int ref_stride,
+                                          uint32_t* sad_array);
+
+unsigned int aom_sad_skip_32x32_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int aom_sad_skip_32x32_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+unsigned int aom_sad_skip_32x32_avx2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+RTCD_EXTERN unsigned int (*aom_sad_skip_32x32)(const uint8_t* src_ptr,
+                                               int src_stride,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride);
+
+void aom_sad_skip_32x32x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void aom_sad_skip_32x32x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+void aom_sad_skip_32x32x4d_avx2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+RTCD_EXTERN void (*aom_sad_skip_32x32x4d)(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* const ref_ptr[],
+                                          int ref_stride,
+                                          uint32_t* sad_array);
+
+unsigned int aom_sad_skip_32x64_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int aom_sad_skip_32x64_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+unsigned int aom_sad_skip_32x64_avx2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+RTCD_EXTERN unsigned int (*aom_sad_skip_32x64)(const uint8_t* src_ptr,
+                                               int src_stride,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride);
+
+void aom_sad_skip_32x64x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void aom_sad_skip_32x64x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+void aom_sad_skip_32x64x4d_avx2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+RTCD_EXTERN void (*aom_sad_skip_32x64x4d)(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* const ref_ptr[],
+                                          int ref_stride,
+                                          uint32_t* sad_array);
+
+unsigned int aom_sad_skip_32x8_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+unsigned int aom_sad_skip_32x8_sse2(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride);
+#define aom_sad_skip_32x8 aom_sad_skip_32x8_sse2
+
+void aom_sad_skip_32x8x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+void aom_sad_skip_32x8x4d_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+void aom_sad_skip_32x8x4d_avx2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+RTCD_EXTERN void (*aom_sad_skip_32x8x4d)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* const ref_ptr[],
+                                         int ref_stride,
+                                         uint32_t* sad_array);
+
+unsigned int aom_sad_skip_4x16_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+unsigned int aom_sad_skip_4x16_sse2(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride);
+#define aom_sad_skip_4x16 aom_sad_skip_4x16_sse2
+
+void aom_sad_skip_4x16x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+void aom_sad_skip_4x16x4d_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+#define aom_sad_skip_4x16x4d aom_sad_skip_4x16x4d_sse2
+
+unsigned int aom_sad_skip_4x4_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+#define aom_sad_skip_4x4 aom_sad_skip_4x4_c
+
+void aom_sad_skip_4x4x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+#define aom_sad_skip_4x4x4d aom_sad_skip_4x4x4d_c
+
+unsigned int aom_sad_skip_4x8_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+unsigned int aom_sad_skip_4x8_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+#define aom_sad_skip_4x8 aom_sad_skip_4x8_sse2
+
+void aom_sad_skip_4x8x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+void aom_sad_skip_4x8x4d_sse2(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+#define aom_sad_skip_4x8x4d aom_sad_skip_4x8x4d_sse2
+
+unsigned int aom_sad_skip_64x128_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int aom_sad_skip_64x128_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
+unsigned int aom_sad_skip_64x128_avx2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
+RTCD_EXTERN unsigned int (*aom_sad_skip_64x128)(const uint8_t* src_ptr,
+                                                int src_stride,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride);
+
+void aom_sad_skip_64x128x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void aom_sad_skip_64x128x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
+void aom_sad_skip_64x128x4d_avx2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
+RTCD_EXTERN void (*aom_sad_skip_64x128x4d)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* const ref_ptr[],
+                                           int ref_stride,
+                                           uint32_t* sad_array);
+
+unsigned int aom_sad_skip_64x16_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int aom_sad_skip_64x16_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+#define aom_sad_skip_64x16 aom_sad_skip_64x16_sse2
+
+void aom_sad_skip_64x16x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void aom_sad_skip_64x16x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+void aom_sad_skip_64x16x4d_avx2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+RTCD_EXTERN void (*aom_sad_skip_64x16x4d)(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* const ref_ptr[],
+                                          int ref_stride,
+                                          uint32_t* sad_array);
+
+unsigned int aom_sad_skip_64x32_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int aom_sad_skip_64x32_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+unsigned int aom_sad_skip_64x32_avx2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+RTCD_EXTERN unsigned int (*aom_sad_skip_64x32)(const uint8_t* src_ptr,
+                                               int src_stride,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride);
+
+void aom_sad_skip_64x32x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void aom_sad_skip_64x32x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+void aom_sad_skip_64x32x4d_avx2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+RTCD_EXTERN void (*aom_sad_skip_64x32x4d)(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* const ref_ptr[],
+                                          int ref_stride,
+                                          uint32_t* sad_array);
+
+unsigned int aom_sad_skip_64x64_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int aom_sad_skip_64x64_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+unsigned int aom_sad_skip_64x64_avx2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+RTCD_EXTERN unsigned int (*aom_sad_skip_64x64)(const uint8_t* src_ptr,
+                                               int src_stride,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride);
+
+void aom_sad_skip_64x64x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void aom_sad_skip_64x64x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+void aom_sad_skip_64x64x4d_avx2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+RTCD_EXTERN void (*aom_sad_skip_64x64x4d)(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* const ref_ptr[],
+                                          int ref_stride,
+                                          uint32_t* sad_array);
+
+unsigned int aom_sad_skip_8x16_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+unsigned int aom_sad_skip_8x16_sse2(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride);
+#define aom_sad_skip_8x16 aom_sad_skip_8x16_sse2
+
+void aom_sad_skip_8x16x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+void aom_sad_skip_8x16x4d_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+#define aom_sad_skip_8x16x4d aom_sad_skip_8x16x4d_sse2
+
+unsigned int aom_sad_skip_8x32_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+unsigned int aom_sad_skip_8x32_sse2(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride);
+#define aom_sad_skip_8x32 aom_sad_skip_8x32_sse2
+
+void aom_sad_skip_8x32x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+void aom_sad_skip_8x32x4d_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+#define aom_sad_skip_8x32x4d aom_sad_skip_8x32x4d_sse2
+
+unsigned int aom_sad_skip_8x4_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+#define aom_sad_skip_8x4 aom_sad_skip_8x4_c
+
+void aom_sad_skip_8x4x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+#define aom_sad_skip_8x4x4d aom_sad_skip_8x4x4d_c
+
+unsigned int aom_sad_skip_8x8_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+unsigned int aom_sad_skip_8x8_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+#define aom_sad_skip_8x8 aom_sad_skip_8x8_sse2
+
+void aom_sad_skip_8x8x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+void aom_sad_skip_8x8x4d_sse2(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+#define aom_sad_skip_8x8x4d aom_sad_skip_8x8x4d_sse2
+
 int aom_satd_c(const tran_low_t* coeff, int length);
 int aom_satd_avx2(const tran_low_t* coeff, int length);
 RTCD_EXTERN int (*aom_satd)(const tran_low_t* coeff, int length);
@@ -27124,6 +28384,90 @@
   aom_highbd_sad64x64x4d = aom_highbd_sad64x64x4d_sse2;
   if (flags & HAS_AVX2)
     aom_highbd_sad64x64x4d = aom_highbd_sad64x64x4d_avx2;
+  aom_highbd_sad_skip_128x128 = aom_highbd_sad_skip_128x128_c;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_128x128 = aom_highbd_sad_skip_128x128_avx2;
+  aom_highbd_sad_skip_128x128x4d = aom_highbd_sad_skip_128x128x4d_c;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_128x128x4d = aom_highbd_sad_skip_128x128x4d_avx2;
+  aom_highbd_sad_skip_128x64 = aom_highbd_sad_skip_128x64_c;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_128x64 = aom_highbd_sad_skip_128x64_avx2;
+  aom_highbd_sad_skip_128x64x4d = aom_highbd_sad_skip_128x64x4d_c;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_128x64x4d = aom_highbd_sad_skip_128x64x4d_avx2;
+  aom_highbd_sad_skip_16x16 = aom_highbd_sad_skip_16x16_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_16x16 = aom_highbd_sad_skip_16x16_avx2;
+  aom_highbd_sad_skip_16x16x4d = aom_highbd_sad_skip_16x16x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_16x16x4d = aom_highbd_sad_skip_16x16x4d_avx2;
+  aom_highbd_sad_skip_16x32 = aom_highbd_sad_skip_16x32_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_16x32 = aom_highbd_sad_skip_16x32_avx2;
+  aom_highbd_sad_skip_16x32x4d = aom_highbd_sad_skip_16x32x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_16x32x4d = aom_highbd_sad_skip_16x32x4d_avx2;
+  aom_highbd_sad_skip_16x64 = aom_highbd_sad_skip_16x64_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_16x64 = aom_highbd_sad_skip_16x64_avx2;
+  aom_highbd_sad_skip_16x64x4d = aom_highbd_sad_skip_16x64x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_16x64x4d = aom_highbd_sad_skip_16x64x4d_avx2;
+  aom_highbd_sad_skip_16x8 = aom_highbd_sad_skip_16x8_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_16x8 = aom_highbd_sad_skip_16x8_avx2;
+  aom_highbd_sad_skip_16x8x4d = aom_highbd_sad_skip_16x8x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_16x8x4d = aom_highbd_sad_skip_16x8x4d_avx2;
+  aom_highbd_sad_skip_32x16 = aom_highbd_sad_skip_32x16_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_32x16 = aom_highbd_sad_skip_32x16_avx2;
+  aom_highbd_sad_skip_32x16x4d = aom_highbd_sad_skip_32x16x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_32x16x4d = aom_highbd_sad_skip_32x16x4d_avx2;
+  aom_highbd_sad_skip_32x32 = aom_highbd_sad_skip_32x32_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_32x32 = aom_highbd_sad_skip_32x32_avx2;
+  aom_highbd_sad_skip_32x32x4d = aom_highbd_sad_skip_32x32x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_32x32x4d = aom_highbd_sad_skip_32x32x4d_avx2;
+  aom_highbd_sad_skip_32x64 = aom_highbd_sad_skip_32x64_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_32x64 = aom_highbd_sad_skip_32x64_avx2;
+  aom_highbd_sad_skip_32x64x4d = aom_highbd_sad_skip_32x64x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_32x64x4d = aom_highbd_sad_skip_32x64x4d_avx2;
+  aom_highbd_sad_skip_32x8 = aom_highbd_sad_skip_32x8_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_32x8 = aom_highbd_sad_skip_32x8_avx2;
+  aom_highbd_sad_skip_32x8x4d = aom_highbd_sad_skip_32x8x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_32x8x4d = aom_highbd_sad_skip_32x8x4d_avx2;
+  aom_highbd_sad_skip_64x128 = aom_highbd_sad_skip_64x128_c;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_64x128 = aom_highbd_sad_skip_64x128_avx2;
+  aom_highbd_sad_skip_64x128x4d = aom_highbd_sad_skip_64x128x4d_c;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_64x128x4d = aom_highbd_sad_skip_64x128x4d_avx2;
+  aom_highbd_sad_skip_64x16 = aom_highbd_sad_skip_64x16_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_64x16 = aom_highbd_sad_skip_64x16_avx2;
+  aom_highbd_sad_skip_64x16x4d = aom_highbd_sad_skip_64x16x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_64x16x4d = aom_highbd_sad_skip_64x16x4d_avx2;
+  aom_highbd_sad_skip_64x32 = aom_highbd_sad_skip_64x32_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_64x32 = aom_highbd_sad_skip_64x32_avx2;
+  aom_highbd_sad_skip_64x32x4d = aom_highbd_sad_skip_64x32x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_64x32x4d = aom_highbd_sad_skip_64x32x4d_avx2;
+  aom_highbd_sad_skip_64x64 = aom_highbd_sad_skip_64x64_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_64x64 = aom_highbd_sad_skip_64x64_avx2;
+  aom_highbd_sad_skip_64x64x4d = aom_highbd_sad_skip_64x64x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_64x64x4d = aom_highbd_sad_skip_64x64x4d_avx2;
   aom_highbd_sse = aom_highbd_sse_c;
   if (flags & HAS_SSE4_1)
     aom_highbd_sse = aom_highbd_sse_sse4_1;
@@ -27866,6 +29210,60 @@
   aom_sad64x64x4d = aom_sad64x64x4d_sse2;
   if (flags & HAS_AVX2)
     aom_sad64x64x4d = aom_sad64x64x4d_avx2;
+  aom_sad_skip_128x128 = aom_sad_skip_128x128_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_128x128 = aom_sad_skip_128x128_avx2;
+  aom_sad_skip_128x128x4d = aom_sad_skip_128x128x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_128x128x4d = aom_sad_skip_128x128x4d_avx2;
+  aom_sad_skip_128x64 = aom_sad_skip_128x64_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_128x64 = aom_sad_skip_128x64_avx2;
+  aom_sad_skip_128x64x4d = aom_sad_skip_128x64x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_128x64x4d = aom_sad_skip_128x64x4d_avx2;
+  aom_sad_skip_32x16 = aom_sad_skip_32x16_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_32x16 = aom_sad_skip_32x16_avx2;
+  aom_sad_skip_32x16x4d = aom_sad_skip_32x16x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_32x16x4d = aom_sad_skip_32x16x4d_avx2;
+  aom_sad_skip_32x32 = aom_sad_skip_32x32_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_32x32 = aom_sad_skip_32x32_avx2;
+  aom_sad_skip_32x32x4d = aom_sad_skip_32x32x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_32x32x4d = aom_sad_skip_32x32x4d_avx2;
+  aom_sad_skip_32x64 = aom_sad_skip_32x64_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_32x64 = aom_sad_skip_32x64_avx2;
+  aom_sad_skip_32x64x4d = aom_sad_skip_32x64x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_32x64x4d = aom_sad_skip_32x64x4d_avx2;
+  aom_sad_skip_32x8x4d = aom_sad_skip_32x8x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_32x8x4d = aom_sad_skip_32x8x4d_avx2;
+  aom_sad_skip_64x128 = aom_sad_skip_64x128_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_64x128 = aom_sad_skip_64x128_avx2;
+  aom_sad_skip_64x128x4d = aom_sad_skip_64x128x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_64x128x4d = aom_sad_skip_64x128x4d_avx2;
+  aom_sad_skip_64x16x4d = aom_sad_skip_64x16x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_64x16x4d = aom_sad_skip_64x16x4d_avx2;
+  aom_sad_skip_64x32 = aom_sad_skip_64x32_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_64x32 = aom_sad_skip_64x32_avx2;
+  aom_sad_skip_64x32x4d = aom_sad_skip_64x32x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_64x32x4d = aom_sad_skip_64x32x4d_avx2;
+  aom_sad_skip_64x64 = aom_sad_skip_64x64_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_64x64 = aom_sad_skip_64x64_avx2;
+  aom_sad_skip_64x64x4d = aom_sad_skip_64x64x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_64x64x4d = aom_sad_skip_64x64x4d_avx2;
   aom_satd = aom_satd_c;
   if (flags & HAS_AVX2)
     aom_satd = aom_satd_avx2;

diff --git a/third_party/libaom/source/config/linux/x64/config/av1_rtcd.h b/third_party/libaom/source/config/linux/x64/config/av1_rtcd.h
index b60d6b20..cbd97932 100644
--- a/third_party/libaom/source/config/linux/x64/config/av1_rtcd.h
+++ b/third_party/libaom/source/config/linux/x64/config/av1_rtcd.h

@@ -1439,6 +1439,38 @@
                                   int8_t* const coeff_contexts);
 #define av1_get_nz_map_contexts av1_get_nz_map_contexts_sse2
 
+void av1_highbd_apply_temporal_filter_c(
+    const struct yv12_buffer_config* ref_frame,
+    const struct macroblockd* mbd,
+    const BLOCK_SIZE block_size,
+    const int mb_row,
+    const int mb_col,
+    const int num_planes,
+    const double* noise_levels,
+    const MV* subblock_mvs,
+    const int* subblock_mses,
+    const int q_factor,
+    const int filter_strength,
+    const uint8_t* pred,
+    uint32_t* accum,
+    uint16_t* count);
+void av1_highbd_apply_temporal_filter_sse2(
+    const struct yv12_buffer_config* ref_frame,
+    const struct macroblockd* mbd,
+    const BLOCK_SIZE block_size,
+    const int mb_row,
+    const int mb_col,
+    const int num_planes,
+    const double* noise_levels,
+    const MV* subblock_mvs,
+    const int* subblock_mses,
+    const int q_factor,
+    const int filter_strength,
+    const uint8_t* pred,
+    uint32_t* accum,
+    uint16_t* count);
+#define av1_highbd_apply_temporal_filter av1_highbd_apply_temporal_filter_sse2
+
 int64_t av1_highbd_block_error_c(const tran_low_t* coeff,
                                  const tran_low_t* dqcoeff,
                                  intptr_t block_size,

diff --git a/third_party/libaom/source/config/win/arm64/config/aom_config.asm b/third_party/libaom/source/config/win/arm64/config/aom_config.asm
index c72fccf..137f0909 100644
--- a/third_party/libaom/source/config/win/arm64/config/aom_config.asm
+++ b/third_party/libaom/source/config/win/arm64/config/aom_config.asm

@@ -43,6 +43,7 @@
 CONFIG_MULTITHREAD equ 1
 CONFIG_NN_V2 equ 0
 CONFIG_NORMAL_TILE_MODE equ 1
+CONFIG_OPTICAL_FLOW_API equ 0
 CONFIG_OS_SUPPORT equ 1
 CONFIG_PIC equ 0
 CONFIG_RD_DEBUG equ 0

diff --git a/third_party/libaom/source/config/win/arm64/config/aom_config.h b/third_party/libaom/source/config/win/arm64/config/aom_config.h
index c681827..4a80e2ba 100644
--- a/third_party/libaom/source/config/win/arm64/config/aom_config.h
+++ b/third_party/libaom/source/config/win/arm64/config/aom_config.h

@@ -45,6 +45,7 @@
 #define CONFIG_MULTITHREAD 1
 #define CONFIG_NN_V2 0
 #define CONFIG_NORMAL_TILE_MODE 1
+#define CONFIG_OPTICAL_FLOW_API 0
 #define CONFIG_OS_SUPPORT 1
 #define CONFIG_PIC 0
 #define CONFIG_RD_DEBUG 0

diff --git a/third_party/libaom/source/config/win/arm64/config/aom_dsp_rtcd.h b/third_party/libaom/source/config/win/arm64/config/aom_dsp_rtcd.h
index 0b7aca7..127d985 100644
--- a/third_party/libaom/source/config/win/arm64/config/aom_dsp_rtcd.h
+++ b/third_party/libaom/source/config/win/arm64/config/aom_dsp_rtcd.h

@@ -8789,6 +8789,292 @@
                             uint32_t* sad_array);
 #define aom_highbd_sad8x8x4d aom_highbd_sad8x8x4d_c
 
+unsigned int aom_highbd_sad_skip_128x128_c(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride);
+#define aom_highbd_sad_skip_128x128 aom_highbd_sad_skip_128x128_c
+
+void aom_highbd_sad_skip_128x128x4d_c(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* const ref_ptr[],
+                                      int ref_stride,
+                                      uint32_t* sad_array);
+#define aom_highbd_sad_skip_128x128x4d aom_highbd_sad_skip_128x128x4d_c
+
+unsigned int aom_highbd_sad_skip_128x64_c(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride);
+#define aom_highbd_sad_skip_128x64 aom_highbd_sad_skip_128x64_c
+
+void aom_highbd_sad_skip_128x64x4d_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* const ref_ptr[],
+                                     int ref_stride,
+                                     uint32_t* sad_array);
+#define aom_highbd_sad_skip_128x64x4d aom_highbd_sad_skip_128x64x4d_c
+
+unsigned int aom_highbd_sad_skip_16x16_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_16x16 aom_highbd_sad_skip_16x16_c
+
+void aom_highbd_sad_skip_16x16x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_16x16x4d aom_highbd_sad_skip_16x16x4d_c
+
+unsigned int aom_highbd_sad_skip_16x32_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_16x32 aom_highbd_sad_skip_16x32_c
+
+void aom_highbd_sad_skip_16x32x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_16x32x4d aom_highbd_sad_skip_16x32x4d_c
+
+unsigned int aom_highbd_sad_skip_16x4_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_16x4 aom_highbd_sad_skip_16x4_c
+
+void aom_highbd_sad_skip_16x4x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_16x4x4d aom_highbd_sad_skip_16x4x4d_c
+
+unsigned int aom_highbd_sad_skip_16x64_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_16x64 aom_highbd_sad_skip_16x64_c
+
+void aom_highbd_sad_skip_16x64x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_16x64x4d aom_highbd_sad_skip_16x64x4d_c
+
+unsigned int aom_highbd_sad_skip_16x8_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_16x8 aom_highbd_sad_skip_16x8_c
+
+void aom_highbd_sad_skip_16x8x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_16x8x4d aom_highbd_sad_skip_16x8x4d_c
+
+unsigned int aom_highbd_sad_skip_32x16_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_32x16 aom_highbd_sad_skip_32x16_c
+
+void aom_highbd_sad_skip_32x16x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_32x16x4d aom_highbd_sad_skip_32x16x4d_c
+
+unsigned int aom_highbd_sad_skip_32x32_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_32x32 aom_highbd_sad_skip_32x32_c
+
+void aom_highbd_sad_skip_32x32x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_32x32x4d aom_highbd_sad_skip_32x32x4d_c
+
+unsigned int aom_highbd_sad_skip_32x64_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_32x64 aom_highbd_sad_skip_32x64_c
+
+void aom_highbd_sad_skip_32x64x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_32x64x4d aom_highbd_sad_skip_32x64x4d_c
+
+unsigned int aom_highbd_sad_skip_32x8_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_32x8 aom_highbd_sad_skip_32x8_c
+
+void aom_highbd_sad_skip_32x8x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_32x8x4d aom_highbd_sad_skip_32x8x4d_c
+
+unsigned int aom_highbd_sad_skip_4x16_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_4x16 aom_highbd_sad_skip_4x16_c
+
+void aom_highbd_sad_skip_4x16x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_4x16x4d aom_highbd_sad_skip_4x16x4d_c
+
+unsigned int aom_highbd_sad_skip_4x4_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+#define aom_highbd_sad_skip_4x4 aom_highbd_sad_skip_4x4_c
+
+void aom_highbd_sad_skip_4x4x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+#define aom_highbd_sad_skip_4x4x4d aom_highbd_sad_skip_4x4x4d_c
+
+unsigned int aom_highbd_sad_skip_4x8_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+#define aom_highbd_sad_skip_4x8 aom_highbd_sad_skip_4x8_c
+
+void aom_highbd_sad_skip_4x8x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+#define aom_highbd_sad_skip_4x8x4d aom_highbd_sad_skip_4x8x4d_c
+
+unsigned int aom_highbd_sad_skip_64x128_c(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride);
+#define aom_highbd_sad_skip_64x128 aom_highbd_sad_skip_64x128_c
+
+void aom_highbd_sad_skip_64x128x4d_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* const ref_ptr[],
+                                     int ref_stride,
+                                     uint32_t* sad_array);
+#define aom_highbd_sad_skip_64x128x4d aom_highbd_sad_skip_64x128x4d_c
+
+unsigned int aom_highbd_sad_skip_64x16_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_64x16 aom_highbd_sad_skip_64x16_c
+
+void aom_highbd_sad_skip_64x16x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_64x16x4d aom_highbd_sad_skip_64x16x4d_c
+
+unsigned int aom_highbd_sad_skip_64x32_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_64x32 aom_highbd_sad_skip_64x32_c
+
+void aom_highbd_sad_skip_64x32x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_64x32x4d aom_highbd_sad_skip_64x32x4d_c
+
+unsigned int aom_highbd_sad_skip_64x64_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+#define aom_highbd_sad_skip_64x64 aom_highbd_sad_skip_64x64_c
+
+void aom_highbd_sad_skip_64x64x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+#define aom_highbd_sad_skip_64x64x4d aom_highbd_sad_skip_64x64x4d_c
+
+unsigned int aom_highbd_sad_skip_8x16_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_8x16 aom_highbd_sad_skip_8x16_c
+
+void aom_highbd_sad_skip_8x16x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x16x4d aom_highbd_sad_skip_8x16x4d_c
+
+unsigned int aom_highbd_sad_skip_8x32_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_8x32 aom_highbd_sad_skip_8x32_c
+
+void aom_highbd_sad_skip_8x32x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x32x4d aom_highbd_sad_skip_8x32x4d_c
+
+unsigned int aom_highbd_sad_skip_8x4_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+#define aom_highbd_sad_skip_8x4 aom_highbd_sad_skip_8x4_c
+
+void aom_highbd_sad_skip_8x4x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x4x4d aom_highbd_sad_skip_8x4x4d_c
+
+unsigned int aom_highbd_sad_skip_8x8_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+#define aom_highbd_sad_skip_8x8 aom_highbd_sad_skip_8x8_c
+
+void aom_highbd_sad_skip_8x8x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x8x4d aom_highbd_sad_skip_8x8x4d_c
+
 void aom_highbd_smooth_h_predictor_16x16_c(uint16_t* dst,
                                            ptrdiff_t y_stride,
                                            const uint16_t* above,
@@ -11884,6 +12170,292 @@
                           int height);
 #define aom_sad8xh aom_sad8xh_c
 
+unsigned int aom_sad_skip_128x128_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride);
+#define aom_sad_skip_128x128 aom_sad_skip_128x128_c
+
+void aom_sad_skip_128x128x4d_c(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+#define aom_sad_skip_128x128x4d aom_sad_skip_128x128x4d_c
+
+unsigned int aom_sad_skip_128x64_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+#define aom_sad_skip_128x64 aom_sad_skip_128x64_c
+
+void aom_sad_skip_128x64x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+#define aom_sad_skip_128x64x4d aom_sad_skip_128x64x4d_c
+
+unsigned int aom_sad_skip_16x16_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_16x16 aom_sad_skip_16x16_c
+
+void aom_sad_skip_16x16x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_16x16x4d aom_sad_skip_16x16x4d_c
+
+unsigned int aom_sad_skip_16x32_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_16x32 aom_sad_skip_16x32_c
+
+void aom_sad_skip_16x32x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_16x32x4d aom_sad_skip_16x32x4d_c
+
+unsigned int aom_sad_skip_16x4_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_16x4 aom_sad_skip_16x4_c
+
+void aom_sad_skip_16x4x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_16x4x4d aom_sad_skip_16x4x4d_c
+
+unsigned int aom_sad_skip_16x64_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_16x64 aom_sad_skip_16x64_c
+
+void aom_sad_skip_16x64x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_16x64x4d aom_sad_skip_16x64x4d_c
+
+unsigned int aom_sad_skip_16x8_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_16x8 aom_sad_skip_16x8_c
+
+void aom_sad_skip_16x8x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_16x8x4d aom_sad_skip_16x8x4d_c
+
+unsigned int aom_sad_skip_32x16_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_32x16 aom_sad_skip_32x16_c
+
+void aom_sad_skip_32x16x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_32x16x4d aom_sad_skip_32x16x4d_c
+
+unsigned int aom_sad_skip_32x32_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_32x32 aom_sad_skip_32x32_c
+
+void aom_sad_skip_32x32x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_32x32x4d aom_sad_skip_32x32x4d_c
+
+unsigned int aom_sad_skip_32x64_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_32x64 aom_sad_skip_32x64_c
+
+void aom_sad_skip_32x64x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_32x64x4d aom_sad_skip_32x64x4d_c
+
+unsigned int aom_sad_skip_32x8_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_32x8 aom_sad_skip_32x8_c
+
+void aom_sad_skip_32x8x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_32x8x4d aom_sad_skip_32x8x4d_c
+
+unsigned int aom_sad_skip_4x16_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_4x16 aom_sad_skip_4x16_c
+
+void aom_sad_skip_4x16x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_4x16x4d aom_sad_skip_4x16x4d_c
+
+unsigned int aom_sad_skip_4x4_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+#define aom_sad_skip_4x4 aom_sad_skip_4x4_c
+
+void aom_sad_skip_4x4x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+#define aom_sad_skip_4x4x4d aom_sad_skip_4x4x4d_c
+
+unsigned int aom_sad_skip_4x8_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+#define aom_sad_skip_4x8 aom_sad_skip_4x8_c
+
+void aom_sad_skip_4x8x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+#define aom_sad_skip_4x8x4d aom_sad_skip_4x8x4d_c
+
+unsigned int aom_sad_skip_64x128_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+#define aom_sad_skip_64x128 aom_sad_skip_64x128_c
+
+void aom_sad_skip_64x128x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+#define aom_sad_skip_64x128x4d aom_sad_skip_64x128x4d_c
+
+unsigned int aom_sad_skip_64x16_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_64x16 aom_sad_skip_64x16_c
+
+void aom_sad_skip_64x16x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_64x16x4d aom_sad_skip_64x16x4d_c
+
+unsigned int aom_sad_skip_64x32_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_64x32 aom_sad_skip_64x32_c
+
+void aom_sad_skip_64x32x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_64x32x4d aom_sad_skip_64x32x4d_c
+
+unsigned int aom_sad_skip_64x64_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+#define aom_sad_skip_64x64 aom_sad_skip_64x64_c
+
+void aom_sad_skip_64x64x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+#define aom_sad_skip_64x64x4d aom_sad_skip_64x64x4d_c
+
+unsigned int aom_sad_skip_8x16_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_8x16 aom_sad_skip_8x16_c
+
+void aom_sad_skip_8x16x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_8x16x4d aom_sad_skip_8x16x4d_c
+
+unsigned int aom_sad_skip_8x32_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_8x32 aom_sad_skip_8x32_c
+
+void aom_sad_skip_8x32x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_8x32x4d aom_sad_skip_8x32x4d_c
+
+unsigned int aom_sad_skip_8x4_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+#define aom_sad_skip_8x4 aom_sad_skip_8x4_c
+
+void aom_sad_skip_8x4x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+#define aom_sad_skip_8x4x4d aom_sad_skip_8x4x4d_c
+
+unsigned int aom_sad_skip_8x8_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+#define aom_sad_skip_8x8 aom_sad_skip_8x8_c
+
+void aom_sad_skip_8x8x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+#define aom_sad_skip_8x8x4d aom_sad_skip_8x8x4d_c
+
 int aom_satd_c(const tran_low_t* coeff, int length);
 int aom_satd_neon(const tran_low_t* coeff, int length);
 #define aom_satd aom_satd_neon

diff --git a/third_party/libaom/source/config/win/arm64/config/av1_rtcd.h b/third_party/libaom/source/config/win/arm64/config/av1_rtcd.h
index 60880ef..759f014e 100644
--- a/third_party/libaom/source/config/win/arm64/config/av1_rtcd.h
+++ b/third_party/libaom/source/config/win/arm64/config/av1_rtcd.h

@@ -848,6 +848,23 @@
                                   int8_t* const coeff_contexts);
 #define av1_get_nz_map_contexts av1_get_nz_map_contexts_neon
 
+void av1_highbd_apply_temporal_filter_c(
+    const struct yv12_buffer_config* ref_frame,
+    const struct macroblockd* mbd,
+    const BLOCK_SIZE block_size,
+    const int mb_row,
+    const int mb_col,
+    const int num_planes,
+    const double* noise_levels,
+    const MV* subblock_mvs,
+    const int* subblock_mses,
+    const int q_factor,
+    const int filter_strength,
+    const uint8_t* pred,
+    uint32_t* accum,
+    uint16_t* count);
+#define av1_highbd_apply_temporal_filter av1_highbd_apply_temporal_filter_c
+
 int64_t av1_highbd_block_error_c(const tran_low_t* coeff,
                                  const tran_low_t* dqcoeff,
                                  intptr_t block_size,

diff --git a/third_party/libaom/source/config/win/ia32/config/aom_config.asm b/third_party/libaom/source/config/win/ia32/config/aom_config.asm
index f37a653..b12d1ed7 100644
--- a/third_party/libaom/source/config/win/ia32/config/aom_config.asm
+++ b/third_party/libaom/source/config/win/ia32/config/aom_config.asm

@@ -33,6 +33,7 @@
 %define CONFIG_MULTITHREAD 1
 %define CONFIG_NN_V2 0
 %define CONFIG_NORMAL_TILE_MODE 1
+%define CONFIG_OPTICAL_FLOW_API 0
 %define CONFIG_OS_SUPPORT 1
 %define CONFIG_PIC 1
 %define CONFIG_RD_DEBUG 0

diff --git a/third_party/libaom/source/config/win/ia32/config/aom_config.h b/third_party/libaom/source/config/win/ia32/config/aom_config.h
index 043aad6..ed3f168 100644
--- a/third_party/libaom/source/config/win/ia32/config/aom_config.h
+++ b/third_party/libaom/source/config/win/ia32/config/aom_config.h

@@ -45,6 +45,7 @@
 #define CONFIG_MULTITHREAD 1
 #define CONFIG_NN_V2 0
 #define CONFIG_NORMAL_TILE_MODE 1
+#define CONFIG_OPTICAL_FLOW_API 0
 #define CONFIG_OS_SUPPORT 1
 #define CONFIG_PIC 1
 #define CONFIG_RD_DEBUG 0

diff --git a/third_party/libaom/source/config/win/ia32/config/aom_dsp_rtcd.h b/third_party/libaom/source/config/win/ia32/config/aom_dsp_rtcd.h
index 16b01ee70..d500bf6 100644
--- a/third_party/libaom/source/config/win/ia32/config/aom_dsp_rtcd.h
+++ b/third_party/libaom/source/config/win/ia32/config/aom_dsp_rtcd.h

@@ -16090,6 +16090,663 @@
                                uint32_t* sad_array);
 #define aom_highbd_sad8x8x4d aom_highbd_sad8x8x4d_sse2
 
+unsigned int aom_highbd_sad_skip_128x128_c(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride);
+unsigned int aom_highbd_sad_skip_128x128_avx2(const uint8_t* src_ptr,
+                                              int src_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_128x128)(const uint8_t* src_ptr,
+                                                        int src_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride);
+
+void aom_highbd_sad_skip_128x128x4d_c(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* const ref_ptr[],
+                                      int ref_stride,
+                                      uint32_t* sad_array);
+void aom_highbd_sad_skip_128x128x4d_avx2(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* const ref_ptr[],
+                                         int ref_stride,
+                                         uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_128x128x4d)(
+    const uint8_t* src_ptr,
+    int src_stride,
+    const uint8_t* const ref_ptr[],
+    int ref_stride,
+    uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_128x64_c(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride);
+unsigned int aom_highbd_sad_skip_128x64_avx2(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_128x64)(const uint8_t* src_ptr,
+                                                       int src_stride,
+                                                       const uint8_t* ref_ptr,
+                                                       int ref_stride);
+
+void aom_highbd_sad_skip_128x64x4d_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* const ref_ptr[],
+                                     int ref_stride,
+                                     uint32_t* sad_array);
+void aom_highbd_sad_skip_128x64x4d_avx2(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* const ref_ptr[],
+                                        int ref_stride,
+                                        uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_128x64x4d)(
+    const uint8_t* src_ptr,
+    int src_stride,
+    const uint8_t* const ref_ptr[],
+    int ref_stride,
+    uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_16x16_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+unsigned int aom_highbd_sad_skip_16x16_sse2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+unsigned int aom_highbd_sad_skip_16x16_avx2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_16x16)(const uint8_t* src_ptr,
+                                                      int src_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride);
+
+void aom_highbd_sad_skip_16x16x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+void aom_highbd_sad_skip_16x16x4d_sse2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+void aom_highbd_sad_skip_16x16x4d_avx2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_16x16x4d)(const uint8_t* src_ptr,
+                                                 int src_stride,
+                                                 const uint8_t* const ref_ptr[],
+                                                 int ref_stride,
+                                                 uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_16x32_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+unsigned int aom_highbd_sad_skip_16x32_sse2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+unsigned int aom_highbd_sad_skip_16x32_avx2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_16x32)(const uint8_t* src_ptr,
+                                                      int src_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride);
+
+void aom_highbd_sad_skip_16x32x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+void aom_highbd_sad_skip_16x32x4d_sse2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+void aom_highbd_sad_skip_16x32x4d_avx2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_16x32x4d)(const uint8_t* src_ptr,
+                                                 int src_stride,
+                                                 const uint8_t* const ref_ptr[],
+                                                 int ref_stride,
+                                                 uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_16x4_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_16x4 aom_highbd_sad_skip_16x4_c
+
+void aom_highbd_sad_skip_16x4x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_16x4x4d aom_highbd_sad_skip_16x4x4d_c
+
+unsigned int aom_highbd_sad_skip_16x64_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+unsigned int aom_highbd_sad_skip_16x64_sse2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+unsigned int aom_highbd_sad_skip_16x64_avx2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_16x64)(const uint8_t* src_ptr,
+                                                      int src_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride);
+
+void aom_highbd_sad_skip_16x64x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+void aom_highbd_sad_skip_16x64x4d_sse2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+void aom_highbd_sad_skip_16x64x4d_avx2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_16x64x4d)(const uint8_t* src_ptr,
+                                                 int src_stride,
+                                                 const uint8_t* const ref_ptr[],
+                                                 int ref_stride,
+                                                 uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_16x8_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+unsigned int aom_highbd_sad_skip_16x8_sse2(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride);
+unsigned int aom_highbd_sad_skip_16x8_avx2(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_16x8)(const uint8_t* src_ptr,
+                                                     int src_stride,
+                                                     const uint8_t* ref_ptr,
+                                                     int ref_stride);
+
+void aom_highbd_sad_skip_16x8x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+void aom_highbd_sad_skip_16x8x4d_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* const ref_ptr[],
+                                      int ref_stride,
+                                      uint32_t* sad_array);
+void aom_highbd_sad_skip_16x8x4d_avx2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* const ref_ptr[],
+                                      int ref_stride,
+                                      uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_16x8x4d)(const uint8_t* src_ptr,
+                                                int src_stride,
+                                                const uint8_t* const ref_ptr[],
+                                                int ref_stride,
+                                                uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_32x16_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+unsigned int aom_highbd_sad_skip_32x16_sse2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+unsigned int aom_highbd_sad_skip_32x16_avx2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_32x16)(const uint8_t* src_ptr,
+                                                      int src_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride);
+
+void aom_highbd_sad_skip_32x16x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+void aom_highbd_sad_skip_32x16x4d_sse2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+void aom_highbd_sad_skip_32x16x4d_avx2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_32x16x4d)(const uint8_t* src_ptr,
+                                                 int src_stride,
+                                                 const uint8_t* const ref_ptr[],
+                                                 int ref_stride,
+                                                 uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_32x32_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+unsigned int aom_highbd_sad_skip_32x32_sse2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+unsigned int aom_highbd_sad_skip_32x32_avx2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_32x32)(const uint8_t* src_ptr,
+                                                      int src_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride);
+
+void aom_highbd_sad_skip_32x32x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+void aom_highbd_sad_skip_32x32x4d_sse2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+void aom_highbd_sad_skip_32x32x4d_avx2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_32x32x4d)(const uint8_t* src_ptr,
+                                                 int src_stride,
+                                                 const uint8_t* const ref_ptr[],
+                                                 int ref_stride,
+                                                 uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_32x64_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+unsigned int aom_highbd_sad_skip_32x64_sse2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+unsigned int aom_highbd_sad_skip_32x64_avx2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_32x64)(const uint8_t* src_ptr,
+                                                      int src_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride);
+
+void aom_highbd_sad_skip_32x64x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+void aom_highbd_sad_skip_32x64x4d_sse2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+void aom_highbd_sad_skip_32x64x4d_avx2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_32x64x4d)(const uint8_t* src_ptr,
+                                                 int src_stride,
+                                                 const uint8_t* const ref_ptr[],
+                                                 int ref_stride,
+                                                 uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_32x8_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+unsigned int aom_highbd_sad_skip_32x8_sse2(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride);
+unsigned int aom_highbd_sad_skip_32x8_avx2(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_32x8)(const uint8_t* src_ptr,
+                                                     int src_stride,
+                                                     const uint8_t* ref_ptr,
+                                                     int ref_stride);
+
+void aom_highbd_sad_skip_32x8x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+void aom_highbd_sad_skip_32x8x4d_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* const ref_ptr[],
+                                      int ref_stride,
+                                      uint32_t* sad_array);
+void aom_highbd_sad_skip_32x8x4d_avx2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* const ref_ptr[],
+                                      int ref_stride,
+                                      uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_32x8x4d)(const uint8_t* src_ptr,
+                                                int src_stride,
+                                                const uint8_t* const ref_ptr[],
+                                                int ref_stride,
+                                                uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_4x16_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+unsigned int aom_highbd_sad_skip_4x16_sse2(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride);
+#define aom_highbd_sad_skip_4x16 aom_highbd_sad_skip_4x16_sse2
+
+void aom_highbd_sad_skip_4x16x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+void aom_highbd_sad_skip_4x16x4d_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* const ref_ptr[],
+                                      int ref_stride,
+                                      uint32_t* sad_array);
+#define aom_highbd_sad_skip_4x16x4d aom_highbd_sad_skip_4x16x4d_sse2
+
+unsigned int aom_highbd_sad_skip_4x4_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+#define aom_highbd_sad_skip_4x4 aom_highbd_sad_skip_4x4_c
+
+void aom_highbd_sad_skip_4x4x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+#define aom_highbd_sad_skip_4x4x4d aom_highbd_sad_skip_4x4x4d_c
+
+unsigned int aom_highbd_sad_skip_4x8_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+unsigned int aom_highbd_sad_skip_4x8_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride);
+#define aom_highbd_sad_skip_4x8 aom_highbd_sad_skip_4x8_sse2
+
+void aom_highbd_sad_skip_4x8x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+void aom_highbd_sad_skip_4x8x4d_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* const ref_ptr[],
+                                     int ref_stride,
+                                     uint32_t* sad_array);
+#define aom_highbd_sad_skip_4x8x4d aom_highbd_sad_skip_4x8x4d_sse2
+
+unsigned int aom_highbd_sad_skip_64x128_c(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride);
+unsigned int aom_highbd_sad_skip_64x128_avx2(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_64x128)(const uint8_t* src_ptr,
+                                                       int src_stride,
+                                                       const uint8_t* ref_ptr,
+                                                       int ref_stride);
+
+void aom_highbd_sad_skip_64x128x4d_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* const ref_ptr[],
+                                     int ref_stride,
+                                     uint32_t* sad_array);
+void aom_highbd_sad_skip_64x128x4d_avx2(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* const ref_ptr[],
+                                        int ref_stride,
+                                        uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_64x128x4d)(
+    const uint8_t* src_ptr,
+    int src_stride,
+    const uint8_t* const ref_ptr[],
+    int ref_stride,
+    uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_64x16_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+unsigned int aom_highbd_sad_skip_64x16_sse2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+unsigned int aom_highbd_sad_skip_64x16_avx2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_64x16)(const uint8_t* src_ptr,
+                                                      int src_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride);
+
+void aom_highbd_sad_skip_64x16x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+void aom_highbd_sad_skip_64x16x4d_sse2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+void aom_highbd_sad_skip_64x16x4d_avx2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_64x16x4d)(const uint8_t* src_ptr,
+                                                 int src_stride,
+                                                 const uint8_t* const ref_ptr[],
+                                                 int ref_stride,
+                                                 uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_64x32_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+unsigned int aom_highbd_sad_skip_64x32_sse2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+unsigned int aom_highbd_sad_skip_64x32_avx2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_64x32)(const uint8_t* src_ptr,
+                                                      int src_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride);
+
+void aom_highbd_sad_skip_64x32x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+void aom_highbd_sad_skip_64x32x4d_sse2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+void aom_highbd_sad_skip_64x32x4d_avx2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_64x32x4d)(const uint8_t* src_ptr,
+                                                 int src_stride,
+                                                 const uint8_t* const ref_ptr[],
+                                                 int ref_stride,
+                                                 uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_64x64_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+unsigned int aom_highbd_sad_skip_64x64_sse2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+unsigned int aom_highbd_sad_skip_64x64_avx2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_64x64)(const uint8_t* src_ptr,
+                                                      int src_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride);
+
+void aom_highbd_sad_skip_64x64x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+void aom_highbd_sad_skip_64x64x4d_sse2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+void aom_highbd_sad_skip_64x64x4d_avx2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_64x64x4d)(const uint8_t* src_ptr,
+                                                 int src_stride,
+                                                 const uint8_t* const ref_ptr[],
+                                                 int ref_stride,
+                                                 uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_8x16_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+unsigned int aom_highbd_sad_skip_8x16_sse2(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride);
+#define aom_highbd_sad_skip_8x16 aom_highbd_sad_skip_8x16_sse2
+
+void aom_highbd_sad_skip_8x16x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+void aom_highbd_sad_skip_8x16x4d_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* const ref_ptr[],
+                                      int ref_stride,
+                                      uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x16x4d aom_highbd_sad_skip_8x16x4d_sse2
+
+unsigned int aom_highbd_sad_skip_8x32_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+unsigned int aom_highbd_sad_skip_8x32_sse2(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride);
+#define aom_highbd_sad_skip_8x32 aom_highbd_sad_skip_8x32_sse2
+
+void aom_highbd_sad_skip_8x32x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+void aom_highbd_sad_skip_8x32x4d_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* const ref_ptr[],
+                                      int ref_stride,
+                                      uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x32x4d aom_highbd_sad_skip_8x32x4d_sse2
+
+unsigned int aom_highbd_sad_skip_8x4_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+#define aom_highbd_sad_skip_8x4 aom_highbd_sad_skip_8x4_c
+
+void aom_highbd_sad_skip_8x4x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x4x4d aom_highbd_sad_skip_8x4x4d_c
+
+unsigned int aom_highbd_sad_skip_8x8_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+unsigned int aom_highbd_sad_skip_8x8_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride);
+#define aom_highbd_sad_skip_8x8 aom_highbd_sad_skip_8x8_sse2
+
+void aom_highbd_sad_skip_8x8x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+void aom_highbd_sad_skip_8x8x4d_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* const ref_ptr[],
+                                     int ref_stride,
+                                     uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x8x4d aom_highbd_sad_skip_8x8x4d_sse2
+
 void aom_highbd_smooth_h_predictor_16x16_c(uint16_t* dst,
                                            ptrdiff_t y_stride,
                                            const uint16_t* above,
@@ -22580,6 +23237,609 @@
                              int height);
 #define aom_sad8xh aom_sad8xh_sse2
 
+unsigned int aom_sad_skip_128x128_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride);
+unsigned int aom_sad_skip_128x128_sse2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+unsigned int aom_sad_skip_128x128_avx2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+RTCD_EXTERN unsigned int (*aom_sad_skip_128x128)(const uint8_t* src_ptr,
+                                                 int src_stride,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride);
+
+void aom_sad_skip_128x128x4d_c(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+void aom_sad_skip_128x128x4d_sse2(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+void aom_sad_skip_128x128x4d_avx2(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+RTCD_EXTERN void (*aom_sad_skip_128x128x4d)(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* const ref_ptr[],
+                                            int ref_stride,
+                                            uint32_t* sad_array);
+
+unsigned int aom_sad_skip_128x64_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int aom_sad_skip_128x64_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
+unsigned int aom_sad_skip_128x64_avx2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
+RTCD_EXTERN unsigned int (*aom_sad_skip_128x64)(const uint8_t* src_ptr,
+                                                int src_stride,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride);
+
+void aom_sad_skip_128x64x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void aom_sad_skip_128x64x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
+void aom_sad_skip_128x64x4d_avx2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
+RTCD_EXTERN void (*aom_sad_skip_128x64x4d)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* const ref_ptr[],
+                                           int ref_stride,
+                                           uint32_t* sad_array);
+
+unsigned int aom_sad_skip_16x16_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int aom_sad_skip_16x16_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+#define aom_sad_skip_16x16 aom_sad_skip_16x16_sse2
+
+void aom_sad_skip_16x16x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void aom_sad_skip_16x16x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+#define aom_sad_skip_16x16x4d aom_sad_skip_16x16x4d_sse2
+
+unsigned int aom_sad_skip_16x32_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int aom_sad_skip_16x32_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+#define aom_sad_skip_16x32 aom_sad_skip_16x32_sse2
+
+void aom_sad_skip_16x32x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void aom_sad_skip_16x32x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+#define aom_sad_skip_16x32x4d aom_sad_skip_16x32x4d_sse2
+
+unsigned int aom_sad_skip_16x4_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_16x4 aom_sad_skip_16x4_c
+
+void aom_sad_skip_16x4x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_16x4x4d aom_sad_skip_16x4x4d_c
+
+unsigned int aom_sad_skip_16x64_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int aom_sad_skip_16x64_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+#define aom_sad_skip_16x64 aom_sad_skip_16x64_sse2
+
+void aom_sad_skip_16x64x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void aom_sad_skip_16x64x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+#define aom_sad_skip_16x64x4d aom_sad_skip_16x64x4d_sse2
+
+unsigned int aom_sad_skip_16x8_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+unsigned int aom_sad_skip_16x8_sse2(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride);
+#define aom_sad_skip_16x8 aom_sad_skip_16x8_sse2
+
+void aom_sad_skip_16x8x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+void aom_sad_skip_16x8x4d_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+#define aom_sad_skip_16x8x4d aom_sad_skip_16x8x4d_sse2
+
+unsigned int aom_sad_skip_32x16_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int aom_sad_skip_32x16_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+unsigned int aom_sad_skip_32x16_avx2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+RTCD_EXTERN unsigned int (*aom_sad_skip_32x16)(const uint8_t* src_ptr,
+                                               int src_stride,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride);
+
+void aom_sad_skip_32x16x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void aom_sad_skip_32x16x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+void aom_sad_skip_32x16x4d_avx2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+RTCD_EXTERN void (*aom_sad_skip_32x16x4d)(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* const ref_ptr[],
+                                          int ref_stride,
+                                          uint32_t* sad_array);
+
+unsigned int aom_sad_skip_32x32_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int aom_sad_skip_32x32_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+unsigned int aom_sad_skip_32x32_avx2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+RTCD_EXTERN unsigned int (*aom_sad_skip_32x32)(const uint8_t* src_ptr,
+                                               int src_stride,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride);
+
+void aom_sad_skip_32x32x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void aom_sad_skip_32x32x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+void aom_sad_skip_32x32x4d_avx2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+RTCD_EXTERN void (*aom_sad_skip_32x32x4d)(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* const ref_ptr[],
+                                          int ref_stride,
+                                          uint32_t* sad_array);
+
+unsigned int aom_sad_skip_32x64_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int aom_sad_skip_32x64_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+unsigned int aom_sad_skip_32x64_avx2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+RTCD_EXTERN unsigned int (*aom_sad_skip_32x64)(const uint8_t* src_ptr,
+                                               int src_stride,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride);
+
+void aom_sad_skip_32x64x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void aom_sad_skip_32x64x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+void aom_sad_skip_32x64x4d_avx2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+RTCD_EXTERN void (*aom_sad_skip_32x64x4d)(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* const ref_ptr[],
+                                          int ref_stride,
+                                          uint32_t* sad_array);
+
+unsigned int aom_sad_skip_32x8_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+unsigned int aom_sad_skip_32x8_sse2(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride);
+#define aom_sad_skip_32x8 aom_sad_skip_32x8_sse2
+
+void aom_sad_skip_32x8x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+void aom_sad_skip_32x8x4d_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+void aom_sad_skip_32x8x4d_avx2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+RTCD_EXTERN void (*aom_sad_skip_32x8x4d)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* const ref_ptr[],
+                                         int ref_stride,
+                                         uint32_t* sad_array);
+
+unsigned int aom_sad_skip_4x16_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+unsigned int aom_sad_skip_4x16_sse2(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride);
+#define aom_sad_skip_4x16 aom_sad_skip_4x16_sse2
+
+void aom_sad_skip_4x16x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+void aom_sad_skip_4x16x4d_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+#define aom_sad_skip_4x16x4d aom_sad_skip_4x16x4d_sse2
+
+unsigned int aom_sad_skip_4x4_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+#define aom_sad_skip_4x4 aom_sad_skip_4x4_c
+
+void aom_sad_skip_4x4x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+#define aom_sad_skip_4x4x4d aom_sad_skip_4x4x4d_c
+
+unsigned int aom_sad_skip_4x8_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+unsigned int aom_sad_skip_4x8_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+#define aom_sad_skip_4x8 aom_sad_skip_4x8_sse2
+
+void aom_sad_skip_4x8x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+void aom_sad_skip_4x8x4d_sse2(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+#define aom_sad_skip_4x8x4d aom_sad_skip_4x8x4d_sse2
+
+unsigned int aom_sad_skip_64x128_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int aom_sad_skip_64x128_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
+unsigned int aom_sad_skip_64x128_avx2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
+RTCD_EXTERN unsigned int (*aom_sad_skip_64x128)(const uint8_t* src_ptr,
+                                                int src_stride,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride);
+
+void aom_sad_skip_64x128x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void aom_sad_skip_64x128x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
+void aom_sad_skip_64x128x4d_avx2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
+RTCD_EXTERN void (*aom_sad_skip_64x128x4d)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* const ref_ptr[],
+                                           int ref_stride,
+                                           uint32_t* sad_array);
+
+unsigned int aom_sad_skip_64x16_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int aom_sad_skip_64x16_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+#define aom_sad_skip_64x16 aom_sad_skip_64x16_sse2
+
+void aom_sad_skip_64x16x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void aom_sad_skip_64x16x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+void aom_sad_skip_64x16x4d_avx2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+RTCD_EXTERN void (*aom_sad_skip_64x16x4d)(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* const ref_ptr[],
+                                          int ref_stride,
+                                          uint32_t* sad_array);
+
+unsigned int aom_sad_skip_64x32_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int aom_sad_skip_64x32_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+unsigned int aom_sad_skip_64x32_avx2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+RTCD_EXTERN unsigned int (*aom_sad_skip_64x32)(const uint8_t* src_ptr,
+                                               int src_stride,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride);
+
+void aom_sad_skip_64x32x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void aom_sad_skip_64x32x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+void aom_sad_skip_64x32x4d_avx2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+RTCD_EXTERN void (*aom_sad_skip_64x32x4d)(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* const ref_ptr[],
+                                          int ref_stride,
+                                          uint32_t* sad_array);
+
+unsigned int aom_sad_skip_64x64_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int aom_sad_skip_64x64_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+unsigned int aom_sad_skip_64x64_avx2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+RTCD_EXTERN unsigned int (*aom_sad_skip_64x64)(const uint8_t* src_ptr,
+                                               int src_stride,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride);
+
+void aom_sad_skip_64x64x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void aom_sad_skip_64x64x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+void aom_sad_skip_64x64x4d_avx2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+RTCD_EXTERN void (*aom_sad_skip_64x64x4d)(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* const ref_ptr[],
+                                          int ref_stride,
+                                          uint32_t* sad_array);
+
+unsigned int aom_sad_skip_8x16_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+unsigned int aom_sad_skip_8x16_sse2(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride);
+#define aom_sad_skip_8x16 aom_sad_skip_8x16_sse2
+
+void aom_sad_skip_8x16x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+void aom_sad_skip_8x16x4d_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+#define aom_sad_skip_8x16x4d aom_sad_skip_8x16x4d_sse2
+
+unsigned int aom_sad_skip_8x32_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+unsigned int aom_sad_skip_8x32_sse2(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride);
+#define aom_sad_skip_8x32 aom_sad_skip_8x32_sse2
+
+void aom_sad_skip_8x32x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+void aom_sad_skip_8x32x4d_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+#define aom_sad_skip_8x32x4d aom_sad_skip_8x32x4d_sse2
+
+unsigned int aom_sad_skip_8x4_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+#define aom_sad_skip_8x4 aom_sad_skip_8x4_c
+
+void aom_sad_skip_8x4x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+#define aom_sad_skip_8x4x4d aom_sad_skip_8x4x4d_c
+
+unsigned int aom_sad_skip_8x8_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+unsigned int aom_sad_skip_8x8_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+#define aom_sad_skip_8x8 aom_sad_skip_8x8_sse2
+
+void aom_sad_skip_8x8x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+void aom_sad_skip_8x8x4d_sse2(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+#define aom_sad_skip_8x8x4d aom_sad_skip_8x8x4d_sse2
+
 int aom_satd_c(const tran_low_t* coeff, int length);
 int aom_satd_avx2(const tran_low_t* coeff, int length);
 RTCD_EXTERN int (*aom_satd)(const tran_low_t* coeff, int length);
@@ -27094,6 +28354,90 @@
   aom_highbd_sad64x64x4d = aom_highbd_sad64x64x4d_sse2;
   if (flags & HAS_AVX2)
     aom_highbd_sad64x64x4d = aom_highbd_sad64x64x4d_avx2;
+  aom_highbd_sad_skip_128x128 = aom_highbd_sad_skip_128x128_c;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_128x128 = aom_highbd_sad_skip_128x128_avx2;
+  aom_highbd_sad_skip_128x128x4d = aom_highbd_sad_skip_128x128x4d_c;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_128x128x4d = aom_highbd_sad_skip_128x128x4d_avx2;
+  aom_highbd_sad_skip_128x64 = aom_highbd_sad_skip_128x64_c;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_128x64 = aom_highbd_sad_skip_128x64_avx2;
+  aom_highbd_sad_skip_128x64x4d = aom_highbd_sad_skip_128x64x4d_c;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_128x64x4d = aom_highbd_sad_skip_128x64x4d_avx2;
+  aom_highbd_sad_skip_16x16 = aom_highbd_sad_skip_16x16_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_16x16 = aom_highbd_sad_skip_16x16_avx2;
+  aom_highbd_sad_skip_16x16x4d = aom_highbd_sad_skip_16x16x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_16x16x4d = aom_highbd_sad_skip_16x16x4d_avx2;
+  aom_highbd_sad_skip_16x32 = aom_highbd_sad_skip_16x32_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_16x32 = aom_highbd_sad_skip_16x32_avx2;
+  aom_highbd_sad_skip_16x32x4d = aom_highbd_sad_skip_16x32x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_16x32x4d = aom_highbd_sad_skip_16x32x4d_avx2;
+  aom_highbd_sad_skip_16x64 = aom_highbd_sad_skip_16x64_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_16x64 = aom_highbd_sad_skip_16x64_avx2;
+  aom_highbd_sad_skip_16x64x4d = aom_highbd_sad_skip_16x64x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_16x64x4d = aom_highbd_sad_skip_16x64x4d_avx2;
+  aom_highbd_sad_skip_16x8 = aom_highbd_sad_skip_16x8_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_16x8 = aom_highbd_sad_skip_16x8_avx2;
+  aom_highbd_sad_skip_16x8x4d = aom_highbd_sad_skip_16x8x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_16x8x4d = aom_highbd_sad_skip_16x8x4d_avx2;
+  aom_highbd_sad_skip_32x16 = aom_highbd_sad_skip_32x16_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_32x16 = aom_highbd_sad_skip_32x16_avx2;
+  aom_highbd_sad_skip_32x16x4d = aom_highbd_sad_skip_32x16x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_32x16x4d = aom_highbd_sad_skip_32x16x4d_avx2;
+  aom_highbd_sad_skip_32x32 = aom_highbd_sad_skip_32x32_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_32x32 = aom_highbd_sad_skip_32x32_avx2;
+  aom_highbd_sad_skip_32x32x4d = aom_highbd_sad_skip_32x32x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_32x32x4d = aom_highbd_sad_skip_32x32x4d_avx2;
+  aom_highbd_sad_skip_32x64 = aom_highbd_sad_skip_32x64_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_32x64 = aom_highbd_sad_skip_32x64_avx2;
+  aom_highbd_sad_skip_32x64x4d = aom_highbd_sad_skip_32x64x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_32x64x4d = aom_highbd_sad_skip_32x64x4d_avx2;
+  aom_highbd_sad_skip_32x8 = aom_highbd_sad_skip_32x8_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_32x8 = aom_highbd_sad_skip_32x8_avx2;
+  aom_highbd_sad_skip_32x8x4d = aom_highbd_sad_skip_32x8x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_32x8x4d = aom_highbd_sad_skip_32x8x4d_avx2;
+  aom_highbd_sad_skip_64x128 = aom_highbd_sad_skip_64x128_c;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_64x128 = aom_highbd_sad_skip_64x128_avx2;
+  aom_highbd_sad_skip_64x128x4d = aom_highbd_sad_skip_64x128x4d_c;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_64x128x4d = aom_highbd_sad_skip_64x128x4d_avx2;
+  aom_highbd_sad_skip_64x16 = aom_highbd_sad_skip_64x16_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_64x16 = aom_highbd_sad_skip_64x16_avx2;
+  aom_highbd_sad_skip_64x16x4d = aom_highbd_sad_skip_64x16x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_64x16x4d = aom_highbd_sad_skip_64x16x4d_avx2;
+  aom_highbd_sad_skip_64x32 = aom_highbd_sad_skip_64x32_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_64x32 = aom_highbd_sad_skip_64x32_avx2;
+  aom_highbd_sad_skip_64x32x4d = aom_highbd_sad_skip_64x32x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_64x32x4d = aom_highbd_sad_skip_64x32x4d_avx2;
+  aom_highbd_sad_skip_64x64 = aom_highbd_sad_skip_64x64_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_64x64 = aom_highbd_sad_skip_64x64_avx2;
+  aom_highbd_sad_skip_64x64x4d = aom_highbd_sad_skip_64x64x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_64x64x4d = aom_highbd_sad_skip_64x64x4d_avx2;
   aom_highbd_sse = aom_highbd_sse_c;
   if (flags & HAS_SSE4_1)
     aom_highbd_sse = aom_highbd_sse_sse4_1;
@@ -27832,6 +29176,60 @@
   aom_sad64x64x4d = aom_sad64x64x4d_sse2;
   if (flags & HAS_AVX2)
     aom_sad64x64x4d = aom_sad64x64x4d_avx2;
+  aom_sad_skip_128x128 = aom_sad_skip_128x128_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_128x128 = aom_sad_skip_128x128_avx2;
+  aom_sad_skip_128x128x4d = aom_sad_skip_128x128x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_128x128x4d = aom_sad_skip_128x128x4d_avx2;
+  aom_sad_skip_128x64 = aom_sad_skip_128x64_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_128x64 = aom_sad_skip_128x64_avx2;
+  aom_sad_skip_128x64x4d = aom_sad_skip_128x64x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_128x64x4d = aom_sad_skip_128x64x4d_avx2;
+  aom_sad_skip_32x16 = aom_sad_skip_32x16_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_32x16 = aom_sad_skip_32x16_avx2;
+  aom_sad_skip_32x16x4d = aom_sad_skip_32x16x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_32x16x4d = aom_sad_skip_32x16x4d_avx2;
+  aom_sad_skip_32x32 = aom_sad_skip_32x32_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_32x32 = aom_sad_skip_32x32_avx2;
+  aom_sad_skip_32x32x4d = aom_sad_skip_32x32x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_32x32x4d = aom_sad_skip_32x32x4d_avx2;
+  aom_sad_skip_32x64 = aom_sad_skip_32x64_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_32x64 = aom_sad_skip_32x64_avx2;
+  aom_sad_skip_32x64x4d = aom_sad_skip_32x64x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_32x64x4d = aom_sad_skip_32x64x4d_avx2;
+  aom_sad_skip_32x8x4d = aom_sad_skip_32x8x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_32x8x4d = aom_sad_skip_32x8x4d_avx2;
+  aom_sad_skip_64x128 = aom_sad_skip_64x128_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_64x128 = aom_sad_skip_64x128_avx2;
+  aom_sad_skip_64x128x4d = aom_sad_skip_64x128x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_64x128x4d = aom_sad_skip_64x128x4d_avx2;
+  aom_sad_skip_64x16x4d = aom_sad_skip_64x16x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_64x16x4d = aom_sad_skip_64x16x4d_avx2;
+  aom_sad_skip_64x32 = aom_sad_skip_64x32_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_64x32 = aom_sad_skip_64x32_avx2;
+  aom_sad_skip_64x32x4d = aom_sad_skip_64x32x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_64x32x4d = aom_sad_skip_64x32x4d_avx2;
+  aom_sad_skip_64x64 = aom_sad_skip_64x64_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_64x64 = aom_sad_skip_64x64_avx2;
+  aom_sad_skip_64x64x4d = aom_sad_skip_64x64x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_64x64x4d = aom_sad_skip_64x64x4d_avx2;
   aom_satd = aom_satd_c;
   if (flags & HAS_AVX2)
     aom_satd = aom_satd_avx2;

diff --git a/third_party/libaom/source/config/win/ia32/config/av1_rtcd.h b/third_party/libaom/source/config/win/ia32/config/av1_rtcd.h
index 934c69a..90f686a11 100644
--- a/third_party/libaom/source/config/win/ia32/config/av1_rtcd.h
+++ b/third_party/libaom/source/config/win/ia32/config/av1_rtcd.h

@@ -1439,6 +1439,38 @@
                                   int8_t* const coeff_contexts);
 #define av1_get_nz_map_contexts av1_get_nz_map_contexts_sse2
 
+void av1_highbd_apply_temporal_filter_c(
+    const struct yv12_buffer_config* ref_frame,
+    const struct macroblockd* mbd,
+    const BLOCK_SIZE block_size,
+    const int mb_row,
+    const int mb_col,
+    const int num_planes,
+    const double* noise_levels,
+    const MV* subblock_mvs,
+    const int* subblock_mses,
+    const int q_factor,
+    const int filter_strength,
+    const uint8_t* pred,
+    uint32_t* accum,
+    uint16_t* count);
+void av1_highbd_apply_temporal_filter_sse2(
+    const struct yv12_buffer_config* ref_frame,
+    const struct macroblockd* mbd,
+    const BLOCK_SIZE block_size,
+    const int mb_row,
+    const int mb_col,
+    const int num_planes,
+    const double* noise_levels,
+    const MV* subblock_mvs,
+    const int* subblock_mses,
+    const int q_factor,
+    const int filter_strength,
+    const uint8_t* pred,
+    uint32_t* accum,
+    uint16_t* count);
+#define av1_highbd_apply_temporal_filter av1_highbd_apply_temporal_filter_sse2
+
 int64_t av1_highbd_block_error_c(const tran_low_t* coeff,
                                  const tran_low_t* dqcoeff,
                                  intptr_t block_size,

diff --git a/third_party/libaom/source/config/win/x64/config/aom_config.asm b/third_party/libaom/source/config/win/x64/config/aom_config.asm
index 904632f..3ce568f 100644
--- a/third_party/libaom/source/config/win/x64/config/aom_config.asm
+++ b/third_party/libaom/source/config/win/x64/config/aom_config.asm

@@ -33,6 +33,7 @@
 %define CONFIG_MULTITHREAD 1
 %define CONFIG_NN_V2 0
 %define CONFIG_NORMAL_TILE_MODE 1
+%define CONFIG_OPTICAL_FLOW_API 0
 %define CONFIG_OS_SUPPORT 1
 %define CONFIG_PIC 0
 %define CONFIG_RD_DEBUG 0

diff --git a/third_party/libaom/source/config/win/x64/config/aom_config.h b/third_party/libaom/source/config/win/x64/config/aom_config.h
index abce3590..86e7da1 100644
--- a/third_party/libaom/source/config/win/x64/config/aom_config.h
+++ b/third_party/libaom/source/config/win/x64/config/aom_config.h

@@ -45,6 +45,7 @@
 #define CONFIG_MULTITHREAD 1
 #define CONFIG_NN_V2 0
 #define CONFIG_NORMAL_TILE_MODE 1
+#define CONFIG_OPTICAL_FLOW_API 0
 #define CONFIG_OS_SUPPORT 1
 #define CONFIG_PIC 0
 #define CONFIG_RD_DEBUG 0

diff --git a/third_party/libaom/source/config/win/x64/config/aom_dsp_rtcd.h b/third_party/libaom/source/config/win/x64/config/aom_dsp_rtcd.h
index c199cbb..ca0b8a1 100644
--- a/third_party/libaom/source/config/win/x64/config/aom_dsp_rtcd.h
+++ b/third_party/libaom/source/config/win/x64/config/aom_dsp_rtcd.h

@@ -16093,6 +16093,663 @@
                                uint32_t* sad_array);
 #define aom_highbd_sad8x8x4d aom_highbd_sad8x8x4d_sse2
 
+unsigned int aom_highbd_sad_skip_128x128_c(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride);
+unsigned int aom_highbd_sad_skip_128x128_avx2(const uint8_t* src_ptr,
+                                              int src_stride,
+                                              const uint8_t* ref_ptr,
+                                              int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_128x128)(const uint8_t* src_ptr,
+                                                        int src_stride,
+                                                        const uint8_t* ref_ptr,
+                                                        int ref_stride);
+
+void aom_highbd_sad_skip_128x128x4d_c(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* const ref_ptr[],
+                                      int ref_stride,
+                                      uint32_t* sad_array);
+void aom_highbd_sad_skip_128x128x4d_avx2(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* const ref_ptr[],
+                                         int ref_stride,
+                                         uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_128x128x4d)(
+    const uint8_t* src_ptr,
+    int src_stride,
+    const uint8_t* const ref_ptr[],
+    int ref_stride,
+    uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_128x64_c(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride);
+unsigned int aom_highbd_sad_skip_128x64_avx2(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_128x64)(const uint8_t* src_ptr,
+                                                       int src_stride,
+                                                       const uint8_t* ref_ptr,
+                                                       int ref_stride);
+
+void aom_highbd_sad_skip_128x64x4d_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* const ref_ptr[],
+                                     int ref_stride,
+                                     uint32_t* sad_array);
+void aom_highbd_sad_skip_128x64x4d_avx2(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* const ref_ptr[],
+                                        int ref_stride,
+                                        uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_128x64x4d)(
+    const uint8_t* src_ptr,
+    int src_stride,
+    const uint8_t* const ref_ptr[],
+    int ref_stride,
+    uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_16x16_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+unsigned int aom_highbd_sad_skip_16x16_sse2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+unsigned int aom_highbd_sad_skip_16x16_avx2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_16x16)(const uint8_t* src_ptr,
+                                                      int src_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride);
+
+void aom_highbd_sad_skip_16x16x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+void aom_highbd_sad_skip_16x16x4d_sse2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+void aom_highbd_sad_skip_16x16x4d_avx2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_16x16x4d)(const uint8_t* src_ptr,
+                                                 int src_stride,
+                                                 const uint8_t* const ref_ptr[],
+                                                 int ref_stride,
+                                                 uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_16x32_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+unsigned int aom_highbd_sad_skip_16x32_sse2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+unsigned int aom_highbd_sad_skip_16x32_avx2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_16x32)(const uint8_t* src_ptr,
+                                                      int src_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride);
+
+void aom_highbd_sad_skip_16x32x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+void aom_highbd_sad_skip_16x32x4d_sse2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+void aom_highbd_sad_skip_16x32x4d_avx2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_16x32x4d)(const uint8_t* src_ptr,
+                                                 int src_stride,
+                                                 const uint8_t* const ref_ptr[],
+                                                 int ref_stride,
+                                                 uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_16x4_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+#define aom_highbd_sad_skip_16x4 aom_highbd_sad_skip_16x4_c
+
+void aom_highbd_sad_skip_16x4x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+#define aom_highbd_sad_skip_16x4x4d aom_highbd_sad_skip_16x4x4d_c
+
+unsigned int aom_highbd_sad_skip_16x64_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+unsigned int aom_highbd_sad_skip_16x64_sse2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+unsigned int aom_highbd_sad_skip_16x64_avx2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_16x64)(const uint8_t* src_ptr,
+                                                      int src_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride);
+
+void aom_highbd_sad_skip_16x64x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+void aom_highbd_sad_skip_16x64x4d_sse2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+void aom_highbd_sad_skip_16x64x4d_avx2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_16x64x4d)(const uint8_t* src_ptr,
+                                                 int src_stride,
+                                                 const uint8_t* const ref_ptr[],
+                                                 int ref_stride,
+                                                 uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_16x8_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+unsigned int aom_highbd_sad_skip_16x8_sse2(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride);
+unsigned int aom_highbd_sad_skip_16x8_avx2(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_16x8)(const uint8_t* src_ptr,
+                                                     int src_stride,
+                                                     const uint8_t* ref_ptr,
+                                                     int ref_stride);
+
+void aom_highbd_sad_skip_16x8x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+void aom_highbd_sad_skip_16x8x4d_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* const ref_ptr[],
+                                      int ref_stride,
+                                      uint32_t* sad_array);
+void aom_highbd_sad_skip_16x8x4d_avx2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* const ref_ptr[],
+                                      int ref_stride,
+                                      uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_16x8x4d)(const uint8_t* src_ptr,
+                                                int src_stride,
+                                                const uint8_t* const ref_ptr[],
+                                                int ref_stride,
+                                                uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_32x16_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+unsigned int aom_highbd_sad_skip_32x16_sse2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+unsigned int aom_highbd_sad_skip_32x16_avx2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_32x16)(const uint8_t* src_ptr,
+                                                      int src_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride);
+
+void aom_highbd_sad_skip_32x16x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+void aom_highbd_sad_skip_32x16x4d_sse2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+void aom_highbd_sad_skip_32x16x4d_avx2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_32x16x4d)(const uint8_t* src_ptr,
+                                                 int src_stride,
+                                                 const uint8_t* const ref_ptr[],
+                                                 int ref_stride,
+                                                 uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_32x32_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+unsigned int aom_highbd_sad_skip_32x32_sse2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+unsigned int aom_highbd_sad_skip_32x32_avx2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_32x32)(const uint8_t* src_ptr,
+                                                      int src_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride);
+
+void aom_highbd_sad_skip_32x32x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+void aom_highbd_sad_skip_32x32x4d_sse2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+void aom_highbd_sad_skip_32x32x4d_avx2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_32x32x4d)(const uint8_t* src_ptr,
+                                                 int src_stride,
+                                                 const uint8_t* const ref_ptr[],
+                                                 int ref_stride,
+                                                 uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_32x64_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+unsigned int aom_highbd_sad_skip_32x64_sse2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+unsigned int aom_highbd_sad_skip_32x64_avx2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_32x64)(const uint8_t* src_ptr,
+                                                      int src_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride);
+
+void aom_highbd_sad_skip_32x64x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+void aom_highbd_sad_skip_32x64x4d_sse2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+void aom_highbd_sad_skip_32x64x4d_avx2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_32x64x4d)(const uint8_t* src_ptr,
+                                                 int src_stride,
+                                                 const uint8_t* const ref_ptr[],
+                                                 int ref_stride,
+                                                 uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_32x8_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+unsigned int aom_highbd_sad_skip_32x8_sse2(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride);
+unsigned int aom_highbd_sad_skip_32x8_avx2(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_32x8)(const uint8_t* src_ptr,
+                                                     int src_stride,
+                                                     const uint8_t* ref_ptr,
+                                                     int ref_stride);
+
+void aom_highbd_sad_skip_32x8x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+void aom_highbd_sad_skip_32x8x4d_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* const ref_ptr[],
+                                      int ref_stride,
+                                      uint32_t* sad_array);
+void aom_highbd_sad_skip_32x8x4d_avx2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* const ref_ptr[],
+                                      int ref_stride,
+                                      uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_32x8x4d)(const uint8_t* src_ptr,
+                                                int src_stride,
+                                                const uint8_t* const ref_ptr[],
+                                                int ref_stride,
+                                                uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_4x16_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+unsigned int aom_highbd_sad_skip_4x16_sse2(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride);
+#define aom_highbd_sad_skip_4x16 aom_highbd_sad_skip_4x16_sse2
+
+void aom_highbd_sad_skip_4x16x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+void aom_highbd_sad_skip_4x16x4d_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* const ref_ptr[],
+                                      int ref_stride,
+                                      uint32_t* sad_array);
+#define aom_highbd_sad_skip_4x16x4d aom_highbd_sad_skip_4x16x4d_sse2
+
+unsigned int aom_highbd_sad_skip_4x4_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+#define aom_highbd_sad_skip_4x4 aom_highbd_sad_skip_4x4_c
+
+void aom_highbd_sad_skip_4x4x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+#define aom_highbd_sad_skip_4x4x4d aom_highbd_sad_skip_4x4x4d_c
+
+unsigned int aom_highbd_sad_skip_4x8_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+unsigned int aom_highbd_sad_skip_4x8_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride);
+#define aom_highbd_sad_skip_4x8 aom_highbd_sad_skip_4x8_sse2
+
+void aom_highbd_sad_skip_4x8x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+void aom_highbd_sad_skip_4x8x4d_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* const ref_ptr[],
+                                     int ref_stride,
+                                     uint32_t* sad_array);
+#define aom_highbd_sad_skip_4x8x4d aom_highbd_sad_skip_4x8x4d_sse2
+
+unsigned int aom_highbd_sad_skip_64x128_c(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride);
+unsigned int aom_highbd_sad_skip_64x128_avx2(const uint8_t* src_ptr,
+                                             int src_stride,
+                                             const uint8_t* ref_ptr,
+                                             int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_64x128)(const uint8_t* src_ptr,
+                                                       int src_stride,
+                                                       const uint8_t* ref_ptr,
+                                                       int ref_stride);
+
+void aom_highbd_sad_skip_64x128x4d_c(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* const ref_ptr[],
+                                     int ref_stride,
+                                     uint32_t* sad_array);
+void aom_highbd_sad_skip_64x128x4d_avx2(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* const ref_ptr[],
+                                        int ref_stride,
+                                        uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_64x128x4d)(
+    const uint8_t* src_ptr,
+    int src_stride,
+    const uint8_t* const ref_ptr[],
+    int ref_stride,
+    uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_64x16_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+unsigned int aom_highbd_sad_skip_64x16_sse2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+unsigned int aom_highbd_sad_skip_64x16_avx2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_64x16)(const uint8_t* src_ptr,
+                                                      int src_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride);
+
+void aom_highbd_sad_skip_64x16x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+void aom_highbd_sad_skip_64x16x4d_sse2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+void aom_highbd_sad_skip_64x16x4d_avx2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_64x16x4d)(const uint8_t* src_ptr,
+                                                 int src_stride,
+                                                 const uint8_t* const ref_ptr[],
+                                                 int ref_stride,
+                                                 uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_64x32_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+unsigned int aom_highbd_sad_skip_64x32_sse2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+unsigned int aom_highbd_sad_skip_64x32_avx2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_64x32)(const uint8_t* src_ptr,
+                                                      int src_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride);
+
+void aom_highbd_sad_skip_64x32x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+void aom_highbd_sad_skip_64x32x4d_sse2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+void aom_highbd_sad_skip_64x32x4d_avx2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_64x32x4d)(const uint8_t* src_ptr,
+                                                 int src_stride,
+                                                 const uint8_t* const ref_ptr[],
+                                                 int ref_stride,
+                                                 uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_64x64_c(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* ref_ptr,
+                                         int ref_stride);
+unsigned int aom_highbd_sad_skip_64x64_sse2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+unsigned int aom_highbd_sad_skip_64x64_avx2(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* ref_ptr,
+                                            int ref_stride);
+RTCD_EXTERN unsigned int (*aom_highbd_sad_skip_64x64)(const uint8_t* src_ptr,
+                                                      int src_stride,
+                                                      const uint8_t* ref_ptr,
+                                                      int ref_stride);
+
+void aom_highbd_sad_skip_64x64x4d_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* const ref_ptr[],
+                                    int ref_stride,
+                                    uint32_t* sad_array);
+void aom_highbd_sad_skip_64x64x4d_sse2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+void aom_highbd_sad_skip_64x64x4d_avx2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* const ref_ptr[],
+                                       int ref_stride,
+                                       uint32_t* sad_array);
+RTCD_EXTERN void (*aom_highbd_sad_skip_64x64x4d)(const uint8_t* src_ptr,
+                                                 int src_stride,
+                                                 const uint8_t* const ref_ptr[],
+                                                 int ref_stride,
+                                                 uint32_t* sad_array);
+
+unsigned int aom_highbd_sad_skip_8x16_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+unsigned int aom_highbd_sad_skip_8x16_sse2(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride);
+#define aom_highbd_sad_skip_8x16 aom_highbd_sad_skip_8x16_sse2
+
+void aom_highbd_sad_skip_8x16x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+void aom_highbd_sad_skip_8x16x4d_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* const ref_ptr[],
+                                      int ref_stride,
+                                      uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x16x4d aom_highbd_sad_skip_8x16x4d_sse2
+
+unsigned int aom_highbd_sad_skip_8x32_c(const uint8_t* src_ptr,
+                                        int src_stride,
+                                        const uint8_t* ref_ptr,
+                                        int ref_stride);
+unsigned int aom_highbd_sad_skip_8x32_sse2(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* ref_ptr,
+                                           int ref_stride);
+#define aom_highbd_sad_skip_8x32 aom_highbd_sad_skip_8x32_sse2
+
+void aom_highbd_sad_skip_8x32x4d_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* const ref_ptr[],
+                                   int ref_stride,
+                                   uint32_t* sad_array);
+void aom_highbd_sad_skip_8x32x4d_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* const ref_ptr[],
+                                      int ref_stride,
+                                      uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x32x4d aom_highbd_sad_skip_8x32x4d_sse2
+
+unsigned int aom_highbd_sad_skip_8x4_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+#define aom_highbd_sad_skip_8x4 aom_highbd_sad_skip_8x4_c
+
+void aom_highbd_sad_skip_8x4x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x4x4d aom_highbd_sad_skip_8x4x4d_c
+
+unsigned int aom_highbd_sad_skip_8x8_c(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+unsigned int aom_highbd_sad_skip_8x8_sse2(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* ref_ptr,
+                                          int ref_stride);
+#define aom_highbd_sad_skip_8x8 aom_highbd_sad_skip_8x8_sse2
+
+void aom_highbd_sad_skip_8x8x4d_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+void aom_highbd_sad_skip_8x8x4d_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* const ref_ptr[],
+                                     int ref_stride,
+                                     uint32_t* sad_array);
+#define aom_highbd_sad_skip_8x8x4d aom_highbd_sad_skip_8x8x4d_sse2
+
 void aom_highbd_smooth_h_predictor_16x16_c(uint16_t* dst,
                                            ptrdiff_t y_stride,
                                            const uint16_t* above,
@@ -22607,6 +23264,609 @@
                              int height);
 #define aom_sad8xh aom_sad8xh_sse2
 
+unsigned int aom_sad_skip_128x128_c(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride);
+unsigned int aom_sad_skip_128x128_sse2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+unsigned int aom_sad_skip_128x128_avx2(const uint8_t* src_ptr,
+                                       int src_stride,
+                                       const uint8_t* ref_ptr,
+                                       int ref_stride);
+RTCD_EXTERN unsigned int (*aom_sad_skip_128x128)(const uint8_t* src_ptr,
+                                                 int src_stride,
+                                                 const uint8_t* ref_ptr,
+                                                 int ref_stride);
+
+void aom_sad_skip_128x128x4d_c(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+void aom_sad_skip_128x128x4d_sse2(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+void aom_sad_skip_128x128x4d_avx2(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* const ref_ptr[],
+                                  int ref_stride,
+                                  uint32_t* sad_array);
+RTCD_EXTERN void (*aom_sad_skip_128x128x4d)(const uint8_t* src_ptr,
+                                            int src_stride,
+                                            const uint8_t* const ref_ptr[],
+                                            int ref_stride,
+                                            uint32_t* sad_array);
+
+unsigned int aom_sad_skip_128x64_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int aom_sad_skip_128x64_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
+unsigned int aom_sad_skip_128x64_avx2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
+RTCD_EXTERN unsigned int (*aom_sad_skip_128x64)(const uint8_t* src_ptr,
+                                                int src_stride,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride);
+
+void aom_sad_skip_128x64x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void aom_sad_skip_128x64x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
+void aom_sad_skip_128x64x4d_avx2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
+RTCD_EXTERN void (*aom_sad_skip_128x64x4d)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* const ref_ptr[],
+                                           int ref_stride,
+                                           uint32_t* sad_array);
+
+unsigned int aom_sad_skip_16x16_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int aom_sad_skip_16x16_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+#define aom_sad_skip_16x16 aom_sad_skip_16x16_sse2
+
+void aom_sad_skip_16x16x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void aom_sad_skip_16x16x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+#define aom_sad_skip_16x16x4d aom_sad_skip_16x16x4d_sse2
+
+unsigned int aom_sad_skip_16x32_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int aom_sad_skip_16x32_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+#define aom_sad_skip_16x32 aom_sad_skip_16x32_sse2
+
+void aom_sad_skip_16x32x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void aom_sad_skip_16x32x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+#define aom_sad_skip_16x32x4d aom_sad_skip_16x32x4d_sse2
+
+unsigned int aom_sad_skip_16x4_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+#define aom_sad_skip_16x4 aom_sad_skip_16x4_c
+
+void aom_sad_skip_16x4x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+#define aom_sad_skip_16x4x4d aom_sad_skip_16x4x4d_c
+
+unsigned int aom_sad_skip_16x64_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int aom_sad_skip_16x64_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+#define aom_sad_skip_16x64 aom_sad_skip_16x64_sse2
+
+void aom_sad_skip_16x64x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void aom_sad_skip_16x64x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+#define aom_sad_skip_16x64x4d aom_sad_skip_16x64x4d_sse2
+
+unsigned int aom_sad_skip_16x8_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+unsigned int aom_sad_skip_16x8_sse2(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride);
+#define aom_sad_skip_16x8 aom_sad_skip_16x8_sse2
+
+void aom_sad_skip_16x8x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+void aom_sad_skip_16x8x4d_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+#define aom_sad_skip_16x8x4d aom_sad_skip_16x8x4d_sse2
+
+unsigned int aom_sad_skip_32x16_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int aom_sad_skip_32x16_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+unsigned int aom_sad_skip_32x16_avx2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+RTCD_EXTERN unsigned int (*aom_sad_skip_32x16)(const uint8_t* src_ptr,
+                                               int src_stride,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride);
+
+void aom_sad_skip_32x16x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void aom_sad_skip_32x16x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+void aom_sad_skip_32x16x4d_avx2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+RTCD_EXTERN void (*aom_sad_skip_32x16x4d)(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* const ref_ptr[],
+                                          int ref_stride,
+                                          uint32_t* sad_array);
+
+unsigned int aom_sad_skip_32x32_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int aom_sad_skip_32x32_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+unsigned int aom_sad_skip_32x32_avx2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+RTCD_EXTERN unsigned int (*aom_sad_skip_32x32)(const uint8_t* src_ptr,
+                                               int src_stride,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride);
+
+void aom_sad_skip_32x32x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void aom_sad_skip_32x32x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+void aom_sad_skip_32x32x4d_avx2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+RTCD_EXTERN void (*aom_sad_skip_32x32x4d)(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* const ref_ptr[],
+                                          int ref_stride,
+                                          uint32_t* sad_array);
+
+unsigned int aom_sad_skip_32x64_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int aom_sad_skip_32x64_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+unsigned int aom_sad_skip_32x64_avx2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+RTCD_EXTERN unsigned int (*aom_sad_skip_32x64)(const uint8_t* src_ptr,
+                                               int src_stride,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride);
+
+void aom_sad_skip_32x64x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void aom_sad_skip_32x64x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+void aom_sad_skip_32x64x4d_avx2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+RTCD_EXTERN void (*aom_sad_skip_32x64x4d)(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* const ref_ptr[],
+                                          int ref_stride,
+                                          uint32_t* sad_array);
+
+unsigned int aom_sad_skip_32x8_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+unsigned int aom_sad_skip_32x8_sse2(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride);
+#define aom_sad_skip_32x8 aom_sad_skip_32x8_sse2
+
+void aom_sad_skip_32x8x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+void aom_sad_skip_32x8x4d_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+void aom_sad_skip_32x8x4d_avx2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+RTCD_EXTERN void (*aom_sad_skip_32x8x4d)(const uint8_t* src_ptr,
+                                         int src_stride,
+                                         const uint8_t* const ref_ptr[],
+                                         int ref_stride,
+                                         uint32_t* sad_array);
+
+unsigned int aom_sad_skip_4x16_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+unsigned int aom_sad_skip_4x16_sse2(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride);
+#define aom_sad_skip_4x16 aom_sad_skip_4x16_sse2
+
+void aom_sad_skip_4x16x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+void aom_sad_skip_4x16x4d_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+#define aom_sad_skip_4x16x4d aom_sad_skip_4x16x4d_sse2
+
+unsigned int aom_sad_skip_4x4_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+#define aom_sad_skip_4x4 aom_sad_skip_4x4_c
+
+void aom_sad_skip_4x4x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+#define aom_sad_skip_4x4x4d aom_sad_skip_4x4x4d_c
+
+unsigned int aom_sad_skip_4x8_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+unsigned int aom_sad_skip_4x8_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+#define aom_sad_skip_4x8 aom_sad_skip_4x8_sse2
+
+void aom_sad_skip_4x8x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+void aom_sad_skip_4x8x4d_sse2(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+#define aom_sad_skip_4x8x4d aom_sad_skip_4x8x4d_sse2
+
+unsigned int aom_sad_skip_64x128_c(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+unsigned int aom_sad_skip_64x128_sse2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
+unsigned int aom_sad_skip_64x128_avx2(const uint8_t* src_ptr,
+                                      int src_stride,
+                                      const uint8_t* ref_ptr,
+                                      int ref_stride);
+RTCD_EXTERN unsigned int (*aom_sad_skip_64x128)(const uint8_t* src_ptr,
+                                                int src_stride,
+                                                const uint8_t* ref_ptr,
+                                                int ref_stride);
+
+void aom_sad_skip_64x128x4d_c(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+void aom_sad_skip_64x128x4d_sse2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
+void aom_sad_skip_64x128x4d_avx2(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* const ref_ptr[],
+                                 int ref_stride,
+                                 uint32_t* sad_array);
+RTCD_EXTERN void (*aom_sad_skip_64x128x4d)(const uint8_t* src_ptr,
+                                           int src_stride,
+                                           const uint8_t* const ref_ptr[],
+                                           int ref_stride,
+                                           uint32_t* sad_array);
+
+unsigned int aom_sad_skip_64x16_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int aom_sad_skip_64x16_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+#define aom_sad_skip_64x16 aom_sad_skip_64x16_sse2
+
+void aom_sad_skip_64x16x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void aom_sad_skip_64x16x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+void aom_sad_skip_64x16x4d_avx2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+RTCD_EXTERN void (*aom_sad_skip_64x16x4d)(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* const ref_ptr[],
+                                          int ref_stride,
+                                          uint32_t* sad_array);
+
+unsigned int aom_sad_skip_64x32_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int aom_sad_skip_64x32_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+unsigned int aom_sad_skip_64x32_avx2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+RTCD_EXTERN unsigned int (*aom_sad_skip_64x32)(const uint8_t* src_ptr,
+                                               int src_stride,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride);
+
+void aom_sad_skip_64x32x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void aom_sad_skip_64x32x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+void aom_sad_skip_64x32x4d_avx2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+RTCD_EXTERN void (*aom_sad_skip_64x32x4d)(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* const ref_ptr[],
+                                          int ref_stride,
+                                          uint32_t* sad_array);
+
+unsigned int aom_sad_skip_64x64_c(const uint8_t* src_ptr,
+                                  int src_stride,
+                                  const uint8_t* ref_ptr,
+                                  int ref_stride);
+unsigned int aom_sad_skip_64x64_sse2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+unsigned int aom_sad_skip_64x64_avx2(const uint8_t* src_ptr,
+                                     int src_stride,
+                                     const uint8_t* ref_ptr,
+                                     int ref_stride);
+RTCD_EXTERN unsigned int (*aom_sad_skip_64x64)(const uint8_t* src_ptr,
+                                               int src_stride,
+                                               const uint8_t* ref_ptr,
+                                               int ref_stride);
+
+void aom_sad_skip_64x64x4d_c(const uint8_t* src_ptr,
+                             int src_stride,
+                             const uint8_t* const ref_ptr[],
+                             int ref_stride,
+                             uint32_t* sad_array);
+void aom_sad_skip_64x64x4d_sse2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+void aom_sad_skip_64x64x4d_avx2(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* const ref_ptr[],
+                                int ref_stride,
+                                uint32_t* sad_array);
+RTCD_EXTERN void (*aom_sad_skip_64x64x4d)(const uint8_t* src_ptr,
+                                          int src_stride,
+                                          const uint8_t* const ref_ptr[],
+                                          int ref_stride,
+                                          uint32_t* sad_array);
+
+unsigned int aom_sad_skip_8x16_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+unsigned int aom_sad_skip_8x16_sse2(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride);
+#define aom_sad_skip_8x16 aom_sad_skip_8x16_sse2
+
+void aom_sad_skip_8x16x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+void aom_sad_skip_8x16x4d_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+#define aom_sad_skip_8x16x4d aom_sad_skip_8x16x4d_sse2
+
+unsigned int aom_sad_skip_8x32_c(const uint8_t* src_ptr,
+                                 int src_stride,
+                                 const uint8_t* ref_ptr,
+                                 int ref_stride);
+unsigned int aom_sad_skip_8x32_sse2(const uint8_t* src_ptr,
+                                    int src_stride,
+                                    const uint8_t* ref_ptr,
+                                    int ref_stride);
+#define aom_sad_skip_8x32 aom_sad_skip_8x32_sse2
+
+void aom_sad_skip_8x32x4d_c(const uint8_t* src_ptr,
+                            int src_stride,
+                            const uint8_t* const ref_ptr[],
+                            int ref_stride,
+                            uint32_t* sad_array);
+void aom_sad_skip_8x32x4d_sse2(const uint8_t* src_ptr,
+                               int src_stride,
+                               const uint8_t* const ref_ptr[],
+                               int ref_stride,
+                               uint32_t* sad_array);
+#define aom_sad_skip_8x32x4d aom_sad_skip_8x32x4d_sse2
+
+unsigned int aom_sad_skip_8x4_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+#define aom_sad_skip_8x4 aom_sad_skip_8x4_c
+
+void aom_sad_skip_8x4x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+#define aom_sad_skip_8x4x4d aom_sad_skip_8x4x4d_c
+
+unsigned int aom_sad_skip_8x8_c(const uint8_t* src_ptr,
+                                int src_stride,
+                                const uint8_t* ref_ptr,
+                                int ref_stride);
+unsigned int aom_sad_skip_8x8_sse2(const uint8_t* src_ptr,
+                                   int src_stride,
+                                   const uint8_t* ref_ptr,
+                                   int ref_stride);
+#define aom_sad_skip_8x8 aom_sad_skip_8x8_sse2
+
+void aom_sad_skip_8x8x4d_c(const uint8_t* src_ptr,
+                           int src_stride,
+                           const uint8_t* const ref_ptr[],
+                           int ref_stride,
+                           uint32_t* sad_array);
+void aom_sad_skip_8x8x4d_sse2(const uint8_t* src_ptr,
+                              int src_stride,
+                              const uint8_t* const ref_ptr[],
+                              int ref_stride,
+                              uint32_t* sad_array);
+#define aom_sad_skip_8x8x4d aom_sad_skip_8x8x4d_sse2
+
 int aom_satd_c(const tran_low_t* coeff, int length);
 int aom_satd_avx2(const tran_low_t* coeff, int length);
 RTCD_EXTERN int (*aom_satd)(const tran_low_t* coeff, int length);
@@ -27124,6 +28384,90 @@
   aom_highbd_sad64x64x4d = aom_highbd_sad64x64x4d_sse2;
   if (flags & HAS_AVX2)
     aom_highbd_sad64x64x4d = aom_highbd_sad64x64x4d_avx2;
+  aom_highbd_sad_skip_128x128 = aom_highbd_sad_skip_128x128_c;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_128x128 = aom_highbd_sad_skip_128x128_avx2;
+  aom_highbd_sad_skip_128x128x4d = aom_highbd_sad_skip_128x128x4d_c;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_128x128x4d = aom_highbd_sad_skip_128x128x4d_avx2;
+  aom_highbd_sad_skip_128x64 = aom_highbd_sad_skip_128x64_c;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_128x64 = aom_highbd_sad_skip_128x64_avx2;
+  aom_highbd_sad_skip_128x64x4d = aom_highbd_sad_skip_128x64x4d_c;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_128x64x4d = aom_highbd_sad_skip_128x64x4d_avx2;
+  aom_highbd_sad_skip_16x16 = aom_highbd_sad_skip_16x16_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_16x16 = aom_highbd_sad_skip_16x16_avx2;
+  aom_highbd_sad_skip_16x16x4d = aom_highbd_sad_skip_16x16x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_16x16x4d = aom_highbd_sad_skip_16x16x4d_avx2;
+  aom_highbd_sad_skip_16x32 = aom_highbd_sad_skip_16x32_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_16x32 = aom_highbd_sad_skip_16x32_avx2;
+  aom_highbd_sad_skip_16x32x4d = aom_highbd_sad_skip_16x32x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_16x32x4d = aom_highbd_sad_skip_16x32x4d_avx2;
+  aom_highbd_sad_skip_16x64 = aom_highbd_sad_skip_16x64_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_16x64 = aom_highbd_sad_skip_16x64_avx2;
+  aom_highbd_sad_skip_16x64x4d = aom_highbd_sad_skip_16x64x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_16x64x4d = aom_highbd_sad_skip_16x64x4d_avx2;
+  aom_highbd_sad_skip_16x8 = aom_highbd_sad_skip_16x8_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_16x8 = aom_highbd_sad_skip_16x8_avx2;
+  aom_highbd_sad_skip_16x8x4d = aom_highbd_sad_skip_16x8x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_16x8x4d = aom_highbd_sad_skip_16x8x4d_avx2;
+  aom_highbd_sad_skip_32x16 = aom_highbd_sad_skip_32x16_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_32x16 = aom_highbd_sad_skip_32x16_avx2;
+  aom_highbd_sad_skip_32x16x4d = aom_highbd_sad_skip_32x16x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_32x16x4d = aom_highbd_sad_skip_32x16x4d_avx2;
+  aom_highbd_sad_skip_32x32 = aom_highbd_sad_skip_32x32_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_32x32 = aom_highbd_sad_skip_32x32_avx2;
+  aom_highbd_sad_skip_32x32x4d = aom_highbd_sad_skip_32x32x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_32x32x4d = aom_highbd_sad_skip_32x32x4d_avx2;
+  aom_highbd_sad_skip_32x64 = aom_highbd_sad_skip_32x64_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_32x64 = aom_highbd_sad_skip_32x64_avx2;
+  aom_highbd_sad_skip_32x64x4d = aom_highbd_sad_skip_32x64x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_32x64x4d = aom_highbd_sad_skip_32x64x4d_avx2;
+  aom_highbd_sad_skip_32x8 = aom_highbd_sad_skip_32x8_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_32x8 = aom_highbd_sad_skip_32x8_avx2;
+  aom_highbd_sad_skip_32x8x4d = aom_highbd_sad_skip_32x8x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_32x8x4d = aom_highbd_sad_skip_32x8x4d_avx2;
+  aom_highbd_sad_skip_64x128 = aom_highbd_sad_skip_64x128_c;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_64x128 = aom_highbd_sad_skip_64x128_avx2;
+  aom_highbd_sad_skip_64x128x4d = aom_highbd_sad_skip_64x128x4d_c;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_64x128x4d = aom_highbd_sad_skip_64x128x4d_avx2;
+  aom_highbd_sad_skip_64x16 = aom_highbd_sad_skip_64x16_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_64x16 = aom_highbd_sad_skip_64x16_avx2;
+  aom_highbd_sad_skip_64x16x4d = aom_highbd_sad_skip_64x16x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_64x16x4d = aom_highbd_sad_skip_64x16x4d_avx2;
+  aom_highbd_sad_skip_64x32 = aom_highbd_sad_skip_64x32_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_64x32 = aom_highbd_sad_skip_64x32_avx2;
+  aom_highbd_sad_skip_64x32x4d = aom_highbd_sad_skip_64x32x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_64x32x4d = aom_highbd_sad_skip_64x32x4d_avx2;
+  aom_highbd_sad_skip_64x64 = aom_highbd_sad_skip_64x64_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_64x64 = aom_highbd_sad_skip_64x64_avx2;
+  aom_highbd_sad_skip_64x64x4d = aom_highbd_sad_skip_64x64x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_highbd_sad_skip_64x64x4d = aom_highbd_sad_skip_64x64x4d_avx2;
   aom_highbd_sse = aom_highbd_sse_c;
   if (flags & HAS_SSE4_1)
     aom_highbd_sse = aom_highbd_sse_sse4_1;
@@ -27866,6 +29210,60 @@
   aom_sad64x64x4d = aom_sad64x64x4d_sse2;
   if (flags & HAS_AVX2)
     aom_sad64x64x4d = aom_sad64x64x4d_avx2;
+  aom_sad_skip_128x128 = aom_sad_skip_128x128_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_128x128 = aom_sad_skip_128x128_avx2;
+  aom_sad_skip_128x128x4d = aom_sad_skip_128x128x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_128x128x4d = aom_sad_skip_128x128x4d_avx2;
+  aom_sad_skip_128x64 = aom_sad_skip_128x64_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_128x64 = aom_sad_skip_128x64_avx2;
+  aom_sad_skip_128x64x4d = aom_sad_skip_128x64x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_128x64x4d = aom_sad_skip_128x64x4d_avx2;
+  aom_sad_skip_32x16 = aom_sad_skip_32x16_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_32x16 = aom_sad_skip_32x16_avx2;
+  aom_sad_skip_32x16x4d = aom_sad_skip_32x16x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_32x16x4d = aom_sad_skip_32x16x4d_avx2;
+  aom_sad_skip_32x32 = aom_sad_skip_32x32_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_32x32 = aom_sad_skip_32x32_avx2;
+  aom_sad_skip_32x32x4d = aom_sad_skip_32x32x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_32x32x4d = aom_sad_skip_32x32x4d_avx2;
+  aom_sad_skip_32x64 = aom_sad_skip_32x64_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_32x64 = aom_sad_skip_32x64_avx2;
+  aom_sad_skip_32x64x4d = aom_sad_skip_32x64x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_32x64x4d = aom_sad_skip_32x64x4d_avx2;
+  aom_sad_skip_32x8x4d = aom_sad_skip_32x8x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_32x8x4d = aom_sad_skip_32x8x4d_avx2;
+  aom_sad_skip_64x128 = aom_sad_skip_64x128_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_64x128 = aom_sad_skip_64x128_avx2;
+  aom_sad_skip_64x128x4d = aom_sad_skip_64x128x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_64x128x4d = aom_sad_skip_64x128x4d_avx2;
+  aom_sad_skip_64x16x4d = aom_sad_skip_64x16x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_64x16x4d = aom_sad_skip_64x16x4d_avx2;
+  aom_sad_skip_64x32 = aom_sad_skip_64x32_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_64x32 = aom_sad_skip_64x32_avx2;
+  aom_sad_skip_64x32x4d = aom_sad_skip_64x32x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_64x32x4d = aom_sad_skip_64x32x4d_avx2;
+  aom_sad_skip_64x64 = aom_sad_skip_64x64_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_64x64 = aom_sad_skip_64x64_avx2;
+  aom_sad_skip_64x64x4d = aom_sad_skip_64x64x4d_sse2;
+  if (flags & HAS_AVX2)
+    aom_sad_skip_64x64x4d = aom_sad_skip_64x64x4d_avx2;
   aom_satd = aom_satd_c;
   if (flags & HAS_AVX2)
     aom_satd = aom_satd_avx2;

diff --git a/third_party/libaom/source/config/win/x64/config/av1_rtcd.h b/third_party/libaom/source/config/win/x64/config/av1_rtcd.h
index b60d6b20..cbd97932 100644
--- a/third_party/libaom/source/config/win/x64/config/av1_rtcd.h
+++ b/third_party/libaom/source/config/win/x64/config/av1_rtcd.h

@@ -1439,6 +1439,38 @@
                                   int8_t* const coeff_contexts);
 #define av1_get_nz_map_contexts av1_get_nz_map_contexts_sse2
 
+void av1_highbd_apply_temporal_filter_c(
+    const struct yv12_buffer_config* ref_frame,
+    const struct macroblockd* mbd,
+    const BLOCK_SIZE block_size,
+    const int mb_row,
+    const int mb_col,
+    const int num_planes,
+    const double* noise_levels,
+    const MV* subblock_mvs,
+    const int* subblock_mses,
+    const int q_factor,
+    const int filter_strength,
+    const uint8_t* pred,
+    uint32_t* accum,
+    uint16_t* count);
+void av1_highbd_apply_temporal_filter_sse2(
+    const struct yv12_buffer_config* ref_frame,
+    const struct macroblockd* mbd,
+    const BLOCK_SIZE block_size,
+    const int mb_row,
+    const int mb_col,
+    const int num_planes,
+    const double* noise_levels,
+    const MV* subblock_mvs,
+    const int* subblock_mses,
+    const int q_factor,
+    const int filter_strength,
+    const uint8_t* pred,
+    uint32_t* accum,
+    uint16_t* count);
+#define av1_highbd_apply_temporal_filter av1_highbd_apply_temporal_filter_sse2
+
 int64_t av1_highbd_block_error_c(const tran_low_t* coeff,
                                  const tran_low_t* dqcoeff,
                                  intptr_t block_size,

diff --git a/third_party/tint/README.chromium b/third_party/tint/README.chromium
index 1504806..6c2d810 100644
--- a/third_party/tint/README.chromium
+++ b/third_party/tint/README.chromium

@@ -2,7 +2,7 @@
 Short Name: tint
 URL: https://dawn.googlesource.com/tint
 Version: 0
-Revision: b08e25388629f5a8f467b726ace18df529bba3ef
+Revision: f70065f6222776f60738099b1c1319c9fbc36627
 License: Apache 2.0
 License File: LICENSE
 Security Critical: yes

diff --git a/tools/json_schema_compiler/cpp_bundle_generator.py b/tools/json_schema_compiler/cpp_bundle_generator.py
index 4e4fbf3..544fe6e9 100644
--- a/tools/json_schema_compiler/cpp_bundle_generator.py
+++ b/tools/json_schema_compiler/cpp_bundle_generator.py

@@ -42,6 +42,7 @@
   _RemoveKey(ret, 'nocompile', bool)
   _RemoveKey(ret, 'noinline_doc', bool)
   _RemoveKey(ret, 'jsexterns', object)
+  _RemoveKey(ret, 'manifest_keys', object)
   return ret
 
 def _PrefixSchemaWithNamespace(schema):

diff --git a/tools/json_schema_compiler/cpp_type_generator.py b/tools/json_schema_compiler/cpp_type_generator.py
index 50e475e..24cd7ab 100644
--- a/tools/json_schema_compiler/cpp_type_generator.py
+++ b/tools/json_schema_compiler/cpp_type_generator.py

@@ -164,11 +164,17 @@
     c = Code()
     if self._default_namespace.manifest_keys:
       c.Append('#include "base/strings/string_piece.h"')
+
+    # Note: It's possible that there are multiple dependencies from the same
+    # API. Make sure to only include them once.
+    added_paths = set()
     for namespace, dependencies in self._NamespaceTypeDependencies().items():
       for dependency in dependencies:
         if dependency.hard or include_soft:
-          c.Append('#include "%s/%s.h"' % (namespace.source_file_dir,
-                                           namespace.unix_name))
+          path = '%s/%s.h' % (namespace.source_file_dir, namespace.unix_name)
+          if path not in added_paths:
+            added_paths.add(path)
+            c.Append('#include "%s"' % path)
     return c
 
   def _FindType(self, full_name):
@@ -232,7 +238,13 @@
     """
     deps = set()
     if type_.property_type == PropertyType.REF:
-      deps.add(_TypeDependency(self._FindType(type_.ref_type), hard=hard))
+      underlying_type = self._FindType(type_.ref_type)
+      # Enums from other namespaces are always hard dependencies, since
+      # optional enums are represented via the _NONE value instead of a
+      # pointer.
+      dep_is_hard = (True if underlying_type.property_type == PropertyType.ENUM
+                     else hard)
+      deps.add(_TypeDependency(underlying_type, hard=dep_is_hard))
     elif type_.property_type == PropertyType.ARRAY:
       # Types in containers are hard dependencies because they are stored
       # directly and use move semantics.

diff --git a/tools/json_schema_compiler/cpp_type_generator_test.py b/tools/json_schema_compiler/cpp_type_generator_test.py
index db4e8cff..6a1ca12 100755
--- a/tools/json_schema_compiler/cpp_type_generator_test.py
+++ b/tools/json_schema_compiler/cpp_type_generator_test.py

@@ -54,6 +54,18 @@
     self.objects_movable = self.models['objects_movable'].AddNamespace(
         self.objects_movable_idl[0], 'path/to/objects_movable.idl',
         include_compiler_options=True)
+    self.simple_api_json = CachedLoad('test/simple_api.json')
+    self.simple_api = self.models['simple_api'].AddNamespace(
+        self.simple_api_json[0], 'path/to/simple_api.json')
+    self.crossref_enums_json = CachedLoad('test/crossref_enums.json')
+    self.crossref_enums = self.models['crossref_enums'].AddNamespace(
+        self.crossref_enums_json[0], 'path/to/crossref_enums.json')
+    self.crossref_enums_array_json = CachedLoad(
+        'test/crossref_enums_array.json')
+    self.crossref_enums_array = (
+        self.models['crossref_enums_array'].AddNamespace(
+            self.crossref_enums_array_json[0],
+            'path/to/crossref_enums_array.json'))
 
   def testGenerateIncludesAndForwardDeclarations(self):
     m = model.Model()
@@ -202,5 +214,41 @@
             self.permissions.functions['contains'].callback.params[0].type_,
         is_in_container=True))
 
+  def testHardIncludesForEnums(self):
+    """Tests that enums generate hard includes. Note that it's important to use
+    use a separate file (cross_enums) here to isolate the test case so that
+    other types don't cause the hard-dependency.
+    """
+    m = model.Model()
+    m.AddNamespace(self.crossref_enums_json[0],
+                   'path/to/crossref_enums.json',
+                   environment=CppNamespaceEnvironment('%(namespace)s'))
+    m.AddNamespace(self.simple_api_json[0],
+                   'path/to/simple_api.json',
+                   environment=CppNamespaceEnvironment('%(namespace)s'))
+    manager = CppTypeGenerator(self.models.get('crossref_enums'),
+                               _FakeSchemaLoader(m))
+
+    self.assertEquals('#include "path/to/simple_api.h"',
+                      manager.GenerateIncludes().Render())
+
+  def testHardIncludesForEnumArrays(self):
+    """Tests that enums in arrays generate hard includes. Note that it's
+    important to use a separate file (cross_enums_array) here to isolate the
+    test case so that other types don't cause the hard-dependency.
+    """
+    m = model.Model()
+    m.AddNamespace(self.crossref_enums_json[0],
+                   'path/to/crossref_enums_array.json',
+                   environment=CppNamespaceEnvironment('%(namespace)s'))
+    m.AddNamespace(self.simple_api_json[0],
+                   'path/to/simple_api.json',
+                   environment=CppNamespaceEnvironment('%(namespace)s'))
+    manager = CppTypeGenerator(self.models.get('crossref_enums_array'),
+                               _FakeSchemaLoader(m))
+
+    self.assertEquals('#include "path/to/simple_api.h"',
+                      manager.GenerateIncludes().Render())
+
 if __name__ == '__main__':
   unittest.main()

diff --git a/tools/json_schema_compiler/test/BUILD.gn b/tools/json_schema_compiler/test/BUILD.gn
index f25cc9e..b8ea77c 100644
--- a/tools/json_schema_compiler/test/BUILD.gn
+++ b/tools/json_schema_compiler/test/BUILD.gn

@@ -9,36 +9,45 @@
 
 assert(enable_extensions)
 
+sources_ = [
+  "additional_properties.json",
+  "any.json",
+  "arrays.json",
+  "callbacks.json",
+  "choices.json",
+  "crossref.json",
+  "enums.json",
+  "error_generation.json",
+  "functions_as_parameters.json",
+  "functions_on_types.json",
+  "idl_basics.idl",
+  "idl_object_types.idl",
+  "idl_other_namespace.idl",
+  "idl_other_namespace_sub_namespace.idl",
+  "idl_properties.idl",
+  "objects.json",
+  "objects_movable.idl",
+  "objects_movable_json.json",
+  "simple_api.json",
+]
+
 generated_types("generated_types") {
   visibility = [ ":*" ]
 
-  sources = [
-    "additional_properties.json",
-    "any.json",
-    "arrays.json",
-    "callbacks.json",
-    "choices.json",
-    "crossref.json",
-    "enums.json",
-    "error_generation.json",
-    "functions_as_parameters.json",
-    "functions_on_types.json",
-    "idl_basics.idl",
-    "idl_object_types.idl",
-    "idl_other_namespace.idl",
-    "idl_other_namespace_sub_namespace.idl",
-    "idl_properties.idl",
-    "objects.json",
-    "objects_movable.idl",
-    "objects_movable_json.json",
-    "simple_api.json",
-  ]
+  sources = sources_
 
   root_namespace = "test::api::%(namespace)s"
 
   deps = [ "//extensions/buildflags" ]
 }
 
+generated_json_strings("generated_api_json_strings") {
+  sources = sources_
+  bundle_name = ""
+  visibility = [ ":*" ]
+  root_namespace = "test::api::%(namespace)s"
+}
+
 json_features("features_compiler_test") {
   feature_type = "APIFeature"
   method_name = "CompilerTestAddFeaturesMethod"
@@ -61,6 +70,7 @@
     "error_generation_unittest.cc",
     "functions_as_parameters_unittest.cc",
     "functions_on_types_unittest.cc",
+    "generated_schemas_unittest.cc",
     "idl_schemas_unittest.cc",
     "objects_unittest.cc",
     "simple_api_unittest.cc",
@@ -74,6 +84,7 @@
   public_deps = [ ":features_compiler_test" ]
 
   deps = [
+    ":generated_api_json_strings",
     ":generated_types",
     "//base",
     "//testing/gmock",

diff --git a/tools/json_schema_compiler/test/crossref_enums.json b/tools/json_schema_compiler/test/crossref_enums.json
new file mode 100644
index 0000000..bb84e5c8
--- /dev/null
+++ b/tools/json_schema_compiler/test/crossref_enums.json

@@ -0,0 +1,23 @@
+[
+  {
+    "namespace": "crossref_enums",
+    "description": "The crossref API with only cross ref enums",
+    "dependencies": ["simple_api"],
+    "types": [
+      {
+        "id": "CrossrefType",
+        "type": "object",
+        "properties": {
+          "testEnumOptional": {
+            "$ref": "simple_api.TestEnum",
+            "optional": true
+          },
+          "testEnumOptionalExtra": {
+            "$ref": "simple_api.TestEnum",
+            "optional": true
+          }
+        }
+      }
+    ]
+  }
+]

diff --git a/tools/json_schema_compiler/test/crossref_enums_array.json b/tools/json_schema_compiler/test/crossref_enums_array.json
new file mode 100644
index 0000000..ffde87e5
--- /dev/null
+++ b/tools/json_schema_compiler/test/crossref_enums_array.json

@@ -0,0 +1,19 @@
+[
+  {
+    "namespace": "crossref_enums_array",
+    "description": "The crossref API with only cross ref enums",
+    "dependencies": ["simple_api"],
+    "types": [
+      {
+        "id": "CrossrefType",
+        "type": "object",
+        "properties": {
+          "testEnumArray": {
+            "type": "array",
+            "items": { "$ref": "simple_api.TestEnum" }
+          }
+        }
+      }
+    ]
+  }
+]

diff --git a/tools/json_schema_compiler/test/generated_schemas_unittest.cc b/tools/json_schema_compiler/test/generated_schemas_unittest.cc
new file mode 100644
index 0000000..1438ed9
--- /dev/null
+++ b/tools/json_schema_compiler/test/generated_schemas_unittest.cc

@@ -0,0 +1,29 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "tools/json_schema_compiler/test/generated_schemas.h"
+
+#include "base/json/json_reader.h"
+#include "base/optional.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace {
+
+// Ensure 'manifest_keys' are excluded from the generated schema.
+TEST(GeneratedSchemaTest, ManifestKeysExcluded) {
+  using GeneratedSchemas = ::test::api::GeneratedSchemas;
+  constexpr char kApiName[] = "simple_api";
+
+  ASSERT_TRUE(GeneratedSchemas::IsGenerated(kApiName));
+
+  // The schema string must be in json format.
+  base::Optional<base::Value> json_schema =
+      base::JSONReader::Read(GeneratedSchemas::Get(kApiName));
+  ASSERT_TRUE(json_schema);
+  ASSERT_TRUE(json_schema->is_dict());
+
+  EXPECT_FALSE(json_schema->FindPath("manifest_keys"));
+}
+
+}  // namespace

diff --git a/tools/metrics/histograms/enums.xml b/tools/metrics/histograms/enums.xml
index 1529a29..dd8fb8e9 100644
--- a/tools/metrics/histograms/enums.xml
+++ b/tools/metrics/histograms/enums.xml

@@ -40784,7 +40784,6 @@
       label="ContextualSuggestionsAlternateCardLayout:disabled"/>
   <int value="-1536293422" label="SharedArrayBuffer:enabled"/>
   <int value="-1536242739" label="security-chip"/>
-  <int value="-1535946978" label="MixBrowserTypeTabs:disabled"/>
   <int value="-1535758690" label="AutoplayIgnoreWebAudio:disabled"/>
   <int value="-1535694535" label="PageInfoPerformanceHints:enabled"/>
   <int value="-1533258008" label="CalculateNativeWinOcclusion:enabled"/>
@@ -43673,7 +43672,6 @@
   <int value="1478075250" label="QuickAnswersTextAnnotator:disabled"/>
   <int value="1478461926" label="GlobalMediaControlsPictureInPicture:enabled"/>
   <int value="1479248574" label="disable-voice-input"/>
-  <int value="1480607006" label="MixBrowserTypeTabs:enabled"/>
   <int value="1481562816" label="disable-password-link"/>
   <int value="1482039233" label="SearchSuggestionsOnLocalNtp:disabled"/>
   <int value="1482839038" label="AutofillCreditCardAuthentication:enabled"/>

diff --git a/tools/metrics/histograms/histogram_paths.py b/tools/metrics/histograms/histogram_paths.py
index f491860..a41f7fdd 100755
--- a/tools/metrics/histograms/histogram_paths.py
+++ b/tools/metrics/histograms/histogram_paths.py

@@ -17,7 +17,8 @@
   file_list = []
   for dirName, _, fileList in os.walk(PATH_TO_HISTOGRAMS_XML_DIR):
     for filename in fileList:
-      if filename == 'histograms.xml' or filename == 'histogram_suffixes.xml':
+      if (filename == 'histograms.xml'
+          or filename == 'histogram_suffixes_list.xml'):
         # Compute the relative path of the histograms xml file.
         file_path = os.path.relpath(
           os.path.join(dirName, filename), PATH_TO_HISTOGRAMS_XML_DIR)
@@ -54,10 +55,12 @@
 ALL_TEST_XMLS_RELATIVE = [
     'tools/metrics/histograms/test_data/enums.xml',
     'tools/metrics/histograms/test_data/histograms.xml',
+    'tools/metrics/histograms/test_data/histogram_suffixes_list.xml',
     'tools/metrics/histograms/test_data/ukm.xml',
 ]
 ALL_TEST_XMLS = [path_util.GetInputFile(f) for f in ALL_TEST_XMLS_RELATIVE]
-TEST_ENUMS_XML, TEST_HISTOGRAMS_XML, TEST_UKM_XML = ALL_TEST_XMLS
+(TEST_ENUMS_XML, TEST_HISTOGRAMS_XML, TEST_SUFFIXES_XML,
+ TEST_UKM_XML) = ALL_TEST_XMLS
 
 # The path to the `histogram_index` file.
 HISTOGRAMS_INDEX = path_util.GetInputFile(

diff --git a/tools/metrics/histograms/histograms.xml b/tools/metrics/histograms/histograms.xml
index 20e617b..8f632c7 100644
--- a/tools/metrics/histograms/histograms.xml
+++ b/tools/metrics/histograms/histograms.xml

@@ -46556,6 +46556,9 @@
 
 <histogram name="Download.MapErrorNetworkFailed.NetworkService"
     enum="NetErrorCodes" expires_after="2020-10-04">
+  <obsolete>
+    Removed as of 08/2020.
+  </obsolete>
   <owner>dtrainor@chromium.org</owner>
   <owner>qinmin@chromium.org</owner>
   <summary>
@@ -163060,9 +163063,11 @@
 </histogram>
 
 <histogram name="Settings.StartupPageLoadSettings" enum="SessionStartupPref"
-    expires_after="2020-08-30">
-  <owner>ramyan@chromium.org</owner>
+    expires_after="2021-01-01">
   <owner>mpearson@chromium.org</owner>
+  <owner>ramyan@chromium.org</owner>
+  <owner>tiborg@chromium.org</owner>
+  <owner>chrome-desktop-ntp@google.com</owner>
   <summary>The startup page settings when a profile is loaded.</summary>
 </histogram>
 

diff --git a/tools/metrics/histograms/histograms_index.txt b/tools/metrics/histograms/histograms_index.txt
index 55826a9..5fa0506 100644
--- a/tools/metrics/histograms/histograms_index.txt
+++ b/tools/metrics/histograms/histograms_index.txt

@@ -1,4 +1,4 @@
 tools/metrics/histograms/histograms.xml
 tools/metrics/histograms/histograms_xml/Fingerprint/histograms.xml
 tools/metrics/histograms/histograms_xml/UMA/histograms.xml
-tools/metrics/histograms/histograms_xml/histogram_suffixes.xml
\ No newline at end of file
+tools/metrics/histograms/histograms_xml/histogram_suffixes_list.xml
\ No newline at end of file

diff --git a/tools/metrics/histograms/histograms_xml/histogram_suffixes.xml b/tools/metrics/histograms/histograms_xml/histogram_suffixes_list.xml
similarity index 92%
rename from tools/metrics/histograms/histograms_xml/histogram_suffixes.xml
rename to tools/metrics/histograms/histograms_xml/histogram_suffixes_list.xml
index 60129f5..83db966 100644
--- a/tools/metrics/histograms/histograms_xml/histogram_suffixes.xml
+++ b/tools/metrics/histograms/histograms_xml/histogram_suffixes_list.xml

@@ -5,8 +5,8 @@
 -->
 
 <!--
-This file is used to generate a comprehensive list of Chrome histograms along
-with a detailed description for each histogram.
+This file is used to specify a list of histogram suffixes for existing
+histograms to create their histogram families.
 
 For best practices on writing histogram descriptions, see
 https://chromium.googlesource.com/chromium/src.git/+/HEAD/tools/metrics/histograms/README.md
@@ -14,10 +14,6 @@
 For brief details on how to modify this file to add your description, see
 https://chromium.googlesource.com/chromium/src.git/+/HEAD/tools/metrics/histograms/one-pager.md
 
-Please pretty-print and validate your edits by running the pretty_print.py
-and validate_format.py scripts in the same directory as this file before
-uploading your change for review.
-
 Please send CLs to chromium-metrics-reviews@google.com rather than to specific
 individuals. These CLs will be automatically reassigned to a reviewer within
 about 5 minutes. This approach helps the metrics team to load-balance incoming

diff --git a/tools/metrics/histograms/merge_xml.py b/tools/metrics/histograms/merge_xml.py
index 6bdccf7..697412f 100755
--- a/tools/metrics/histograms/merge_xml.py
+++ b/tools/metrics/histograms/merge_xml.py

@@ -59,24 +59,32 @@
 
 
 def CombineHistogramsSorted(doc, trees):
-  """Sorts <histogram> nodes by name and returns a single <histograms> node.
+  """Sorts histograms related nodes by name and returns the combined nodes.
+
+  This function sorts nodes including <histogram>, <variant> and
+  <histogram_suffix>. Then it returns one <histograms> that contains the
+  sorted <histogram> and <variant> nodes and the other <histogram_suffixes_list>
+  node containing all <histogram_suffixes> nodes.
 
   Args:
     doc: The document to create the node in.
     trees: A list of DOM trees.
 
   Returns:
-    A list containing a single <histograms> node.
+    A list containing the combined <histograms> node and the combined
+    <histogram_suffix_list> node.
   """
+  # Create the combined <histograms> tag.
   combined_histograms = doc.createElement('histograms')
 
+  def SortByLowerCaseName(node):
+    return node.getAttribute('name').lower()
+
   variants_nodes = GetElementsByTagName(trees, 'variants', depth=3)
-  sorted_variants = sorted(variants_nodes,
-                           key=lambda node: node.getAttribute('name').lower())
+  sorted_variants = sorted(variants_nodes, key=SortByLowerCaseName)
 
   histogram_nodes = GetElementsByTagName(trees, 'histogram', depth=3)
-  sorted_histograms = sorted(histogram_nodes,
-                             key=lambda node: node.getAttribute('name').lower())
+  sorted_histograms = sorted(histogram_nodes, key=SortByLowerCaseName)
 
   for variants in sorted_variants:
     # Use unsafe version of `appendChild` function here because the safe one
@@ -89,10 +97,23 @@
     xml.dom.minidom._append_child(combined_histograms, variants)
 
   for histogram in sorted_histograms:
-    # See above comment.
     xml.dom.minidom._append_child(combined_histograms, histogram)
 
-  return [combined_histograms]
+  # Create the combined <histogram_suffixes_list> tag.
+  combined_histogram_suffixes_list = doc.createElement(
+      'histogram_suffixes_list')
+
+  histogram_suffixes_nodes = GetElementsByTagName(trees,
+                                                  'histogram_suffixes',
+                                                  depth=3)
+  sorted_histogram_suffixes = sorted(histogram_suffixes_nodes,
+                                     key=SortByLowerCaseName)
+
+  for histogram_suffixes in sorted_histogram_suffixes:
+    xml.dom.minidom._append_child(combined_histogram_suffixes_list,
+                                  histogram_suffixes)
+
+  return [combined_histograms, combined_histogram_suffixes_list]
 
 
 def MakeNodeWithChildren(doc, tag, children):
@@ -129,9 +150,9 @@
           # This can result in the merged document having multiple <enums> and
           # similar sections, but scripts ignore these anyway.
           GetEnumsNodes(doc, trees) +
-          # Sort the histograms by name and return a single <histograms> node.
-          CombineHistogramsSorted(doc, trees) +
-          GetElementsByTagName(trees, 'histogram_suffixes_list')))
+          # Sort the <histogram> and <histogram_suffixes> nodes by name and
+          # return the combined nodes.
+          CombineHistogramsSorted(doc, trees)))
   # After using the unsafe version of appendChild, we see a regression when
   # pretty-printing the merged |doc|. This might because the unsafe appendChild
   # doesn't build indexes for later lookup. And thus, we need to convert the

diff --git a/tools/metrics/histograms/merge_xml_test.py b/tools/metrics/histograms/merge_xml_test.py
index fc56bcb..0e8609e 100644
--- a/tools/metrics/histograms/merge_xml_test.py
+++ b/tools/metrics/histograms/merge_xml_test.py

@@ -12,8 +12,10 @@
 
   def testMergeFiles(self):
     """Checks that enums.xml and histograms.xml can merge successfully."""
-    merged = merge_xml.PrettyPrintMergedFiles(
-        [histogram_paths.TEST_ENUMS_XML, histogram_paths.TEST_HISTOGRAMS_XML])
+    merged = merge_xml.PrettyPrintMergedFiles([
+        histogram_paths.TEST_ENUMS_XML, histogram_paths.TEST_HISTOGRAMS_XML,
+        histogram_paths.TEST_SUFFIXES_XML
+    ])
     # If ukm.xml is not provided, there is no need to populate the
     # UkmEventNameHash enum.
     expected_merged_xml = """
@@ -84,6 +86,12 @@
 
 <histogram_suffixes_list>
 
+<histogram_suffixes name="Test.EnumHistogramSuffixes" separator="."
+    ordering="prefix,2">
+  <suffix name="TestEnumSuffix" label="The enum histogram_suffixes"/>
+  <affected-histogram name="Test.EnumHistogram"/>
+</histogram_suffixes>
+
 <histogram_suffixes name="Test.HistogramSuffixes" separator=".">
   <suffix name="TestSuffix" label="A histogram_suffixes"/>
   <affected-histogram name="Test.Histogram"/>
@@ -177,6 +185,12 @@
 
 <histogram_suffixes_list>
 
+<histogram_suffixes name="Test.EnumHistogramSuffixes" separator="."
+    ordering="prefix,2">
+  <suffix name="TestEnumSuffix" label="The enum histogram_suffixes"/>
+  <affected-histogram name="Test.EnumHistogram"/>
+</histogram_suffixes>
+
 <histogram_suffixes name="Test.HistogramSuffixes" separator=".">
   <suffix name="TestSuffix" label="A histogram_suffixes"/>
   <affected-histogram name="Test.Histogram"/>

diff --git a/tools/metrics/histograms/test_data/histogram_suffixes_list.xml b/tools/metrics/histograms/test_data/histogram_suffixes_list.xml
new file mode 100644
index 0000000..07a344f
--- /dev/null
+++ b/tools/metrics/histograms/test_data/histogram_suffixes_list.xml

@@ -0,0 +1,13 @@
+<histogram-configuration>
+
+<histogram_suffixes_list>
+
+<histogram_suffixes name="Test.EnumHistogramSuffixes" separator="."
+    ordering="prefix,2">
+  <suffix name="TestEnumSuffix" label="The enum histogram_suffixes"/>
+  <affected-histogram name="Test.EnumHistogram"/>
+</histogram_suffixes>
+
+</histogram_suffixes_list>
+
+</histogram-configuration>
\ No newline at end of file

diff --git a/tools/perf/core/perfetto_binary_roller/binary_deps.json b/tools/perf/core/perfetto_binary_roller/binary_deps.json
index 777fb82..252896d 100644
--- a/tools/perf/core/perfetto_binary_roller/binary_deps.json
+++ b/tools/perf/core/perfetto_binary_roller/binary_deps.json

@@ -6,11 +6,11 @@
         },
         "mac": {
             "hash": "be6a7ab2c70ff31ad87286fee6617d97b436a541",
-            "remote_path": "perfetto_binaries/trace_processor_shell/mac/ff77947e7ecc9ee98750280747e89ac2481d4dba/trace_processor_shell"
+            "remote_path": "perfetto_binaries/trace_processor_shell/mac/7023f47299aa157951b4677ee4450cac58685a2d/trace_processor_shell"
         },
         "linux": {
             "hash": "6cf2b33261fa3274f1c8b56085b924410037460c",
-            "remote_path": "perfetto_binaries/trace_processor_shell/linux/ff77947e7ecc9ee98750280747e89ac2481d4dba/trace_processor_shell"
+            "remote_path": "perfetto_binaries/trace_processor_shell/linux/7023f47299aa157951b4677ee4450cac58685a2d/trace_processor_shell"
         }
     },
     "power_profile.sql": {

diff --git a/ui/android/BUILD.gn b/ui/android/BUILD.gn
index 696b1ad5..1c47709 100644
--- a/ui/android/BUILD.gn
+++ b/ui/android/BUILD.gn

@@ -216,6 +216,7 @@
     "//third_party/android_deps:androidx_appcompat_appcompat_java",
     "//third_party/android_deps:androidx_appcompat_appcompat_resources_java",
     "//third_party/android_deps:androidx_core_core_java",
+    "//third_party/blink/public/mojom:android_mojo_bindings_java",
     "//third_party/blink/public/mojom:mojom_platform_java",
   ]
 }

diff --git a/ui/base/clipboard/clipboard_monitor.cc b/ui/base/clipboard/clipboard_monitor.cc
index b8bd094..1d5cd55 100644
--- a/ui/base/clipboard/clipboard_monitor.cc
+++ b/ui/base/clipboard/clipboard_monitor.cc

@@ -27,6 +27,14 @@
     observer.OnClipboardDataChanged();
 }
 
+#if defined(OS_CHROMEOS)
+void ClipboardMonitor::NotifyClipboardDataRead() {
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
+  for (ClipboardObserver& observer : observers_)
+    observer.OnClipboardDataRead();
+}
+#endif
+
 void ClipboardMonitor::AddObserver(ClipboardObserver* observer) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   observers_.AddObserver(observer);

diff --git a/ui/base/clipboard/clipboard_monitor.h b/ui/base/clipboard/clipboard_monitor.h
index a1711f2a..d09aafaa 100644
--- a/ui/base/clipboard/clipboard_monitor.h
+++ b/ui/base/clipboard/clipboard_monitor.h

@@ -10,6 +10,7 @@
 #include "base/no_destructor.h"
 #include "base/observer_list.h"
 #include "base/threading/thread_checker.h"
+#include "build/build_config.h"
 
 namespace ui {
 
@@ -30,6 +31,11 @@
   // Notifies all observers for clipboard data change.
   virtual void NotifyClipboardDataChanged();
 
+#if defined(OS_CHROMEOS)
+  // Notifies all observers for clipboard data read.
+  virtual void NotifyClipboardDataRead();
+#endif
+
  private:
   friend class base::NoDestructor<ClipboardMonitor>;
 

diff --git a/ui/base/clipboard/clipboard_non_backed.cc b/ui/base/clipboard/clipboard_non_backed.cc
index db4ff59..c8fc072 100644
--- a/ui/base/clipboard/clipboard_non_backed.cc
+++ b/ui/base/clipboard/clipboard_non_backed.cc

@@ -213,7 +213,6 @@
     if (!HasFormat(ClipboardInternalFormat::kCustom) ||
         type != data->custom_data_format())
       return;
-
     *result = data->custom_data_data();
   }
 
@@ -503,6 +502,10 @@
 
   RecordRead(ClipboardFormatMetric::kText);
   clipboard_internal_->ReadText(result);
+
+#if defined(OS_CHROMEOS)
+  ClipboardMonitor::GetInstance()->NotifyClipboardDataRead();
+#endif
 }
 
 void ClipboardNonBacked::ReadAsciiText(ClipboardBuffer buffer,
@@ -515,6 +518,10 @@
 
   RecordRead(ClipboardFormatMetric::kText);
   clipboard_internal_->ReadAsciiText(result);
+
+#if defined(OS_CHROMEOS)
+  ClipboardMonitor::GetInstance()->NotifyClipboardDataRead();
+#endif
 }
 
 void ClipboardNonBacked::ReadHTML(ClipboardBuffer buffer,
@@ -530,6 +537,10 @@
 
   RecordRead(ClipboardFormatMetric::kHtml);
   clipboard_internal_->ReadHTML(markup, src_url, fragment_start, fragment_end);
+
+#if defined(OS_CHROMEOS)
+  ClipboardMonitor::GetInstance()->NotifyClipboardDataRead();
+#endif
 }
 
 void ClipboardNonBacked::ReadRTF(ClipboardBuffer buffer,
@@ -542,6 +553,10 @@
 
   RecordRead(ClipboardFormatMetric::kRtf);
   clipboard_internal_->ReadRTF(result);
+
+#if defined(OS_CHROMEOS)
+  ClipboardMonitor::GetInstance()->NotifyClipboardDataRead();
+#endif
 }
 
 void ClipboardNonBacked::ReadImage(ClipboardBuffer buffer,
@@ -554,6 +569,10 @@
 
   RecordRead(ClipboardFormatMetric::kImage);
   std::move(callback).Run(clipboard_internal_->ReadImage());
+
+#if defined(OS_CHROMEOS)
+  ClipboardMonitor::GetInstance()->NotifyClipboardDataRead();
+#endif
 }
 
 void ClipboardNonBacked::ReadCustomData(ClipboardBuffer buffer,
@@ -567,6 +586,10 @@
 
   RecordRead(ClipboardFormatMetric::kCustomData);
   clipboard_internal_->ReadCustomData(type, result);
+
+#if defined(OS_CHROMEOS)
+  ClipboardMonitor::GetInstance()->NotifyClipboardDataRead();
+#endif
 }
 
 void ClipboardNonBacked::ReadBookmark(const ClipboardDataEndpoint* data_dst,
@@ -579,6 +602,10 @@
 
   RecordRead(ClipboardFormatMetric::kBookmark);
   clipboard_internal_->ReadBookmark(title, url);
+
+#if defined(OS_CHROMEOS)
+  ClipboardMonitor::GetInstance()->NotifyClipboardDataRead();
+#endif
 }
 
 void ClipboardNonBacked::ReadData(const ClipboardFormatType& format,
@@ -591,6 +618,10 @@
 
   RecordRead(ClipboardFormatMetric::kData);
   clipboard_internal_->ReadData(format.GetName(), result);
+
+#if defined(OS_CHROMEOS)
+  ClipboardMonitor::GetInstance()->NotifyClipboardDataRead();
+#endif
 }
 
 bool ClipboardNonBacked::IsSelectionBufferAvailable() const {

diff --git a/ui/base/clipboard/clipboard_non_backed_unittest.cc b/ui/base/clipboard/clipboard_non_backed_unittest.cc
index 0d58bf6a..4fa7c18 100644
--- a/ui/base/clipboard/clipboard_non_backed_unittest.cc
+++ b/ui/base/clipboard/clipboard_non_backed_unittest.cc

@@ -6,6 +6,7 @@
 
 #include <memory>
 
+#include "base/test/metrics/histogram_tester.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/clipboard/clipboard_data.h"
 
@@ -54,4 +55,23 @@
   EXPECT_EQ(second_data_ptr, clipboard()->GetClipboardData(nullptr));
 }
 
+// Verifies that directly writing to ClipboardInternal does not result in
+// histograms being logged. This is used by ClipboardHistoryController to
+// manipulate the clipboard in order to facilitate pasting from clipboard
+// history.
+TEST_F(ClipboardNonBackedTest, AdminWriteDoesNotRecordHistograms) {
+  base::HistogramTester histogram_tester;
+  auto data = std::make_unique<ClipboardData>();
+  data->set_text("test");
+
+  auto* data_ptr = data.get();
+
+  // Write the data to the clipboard, no histograms should be recorded.
+  clipboard()->WriteClipboardData(std::move(data));
+  EXPECT_EQ(data_ptr, clipboard()->GetClipboardData(/*data_dst=*/nullptr));
+
+  histogram_tester.ExpectTotalCount("Clipboard.Read", 0);
+  histogram_tester.ExpectTotalCount("Clipboard.Write", 0);
+}
+
 }  // namespace ui

diff --git a/ui/base/clipboard/clipboard_observer.h b/ui/base/clipboard/clipboard_observer.h
index d630581..3e4469d 100644
--- a/ui/base/clipboard/clipboard_observer.h
+++ b/ui/base/clipboard/clipboard_observer.h

@@ -7,6 +7,7 @@
 
 #include "base/component_export.h"
 #include "base/macros.h"
+#include "build/build_config.h"
 
 namespace ui {
 
@@ -16,6 +17,11 @@
   // Called when clipboard data is changed.
   virtual void OnClipboardDataChanged() = 0;
 
+#if defined(OS_CHROMEOS)
+  // Called when clipboard data is read.
+  virtual void OnClipboardDataRead() = 0;
+#endif
+
  protected:
   virtual ~ClipboardObserver() = default;
 };

diff --git a/ui/base/clipboard/clipboard_test_template.h b/ui/base/clipboard/clipboard_test_template.h
index 828b283a..62475dd 100644
--- a/ui/base/clipboard/clipboard_test_template.h
+++ b/ui/base/clipboard/clipboard_test_template.h

@@ -44,6 +44,7 @@
 #include "ui/base/clipboard/scoped_clipboard_writer.h"
 #include "ui/base/clipboard/test/clipboard_test_util.h"
 #include "ui/base/clipboard/test/test_clipboard.h"
+#include "ui/base/ui_base_features.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/half_float.h"
 #include "url/origin.h"
@@ -53,7 +54,6 @@
 #endif
 
 #if defined(USE_X11)
-#include "ui/base/ui_base_features.h"
 #include "ui/events/platform/platform_event_source.h"
 #endif
 

diff --git a/ui/base/ui_features.gni b/ui/base/ui_features.gni
index e5203cd..e2ac40d 100644
--- a/ui/base/ui_features.gni
+++ b/ui/base/ui_features.gni

@@ -12,7 +12,8 @@
   has_native_accessibility = use_atk || is_win || is_mac
 
   # Whether the message center should be included for displaying notifications.
-  enable_message_center = is_win || is_mac || is_linux || is_chromeos || is_fuchsia
+  enable_message_center =
+      is_win || is_mac || is_linux || is_chromeos || is_fuchsia
 }
 
 enable_hidpi = is_mac || is_win || is_linux || is_chromeos || is_ios

diff --git a/ui/gfx/color_space.cc b/ui/gfx/color_space.cc
index 768f84f..f6eb5f8 100644
--- a/ui/gfx/color_space.cc
+++ b/ui/gfx/color_space.cc

@@ -595,7 +595,7 @@
 
 ColorSpace ColorSpace::GetWithSDRWhiteLevel(float sdr_white_level) const {
   ColorSpace result = *this;
-  if (transfer_ == TransferID::SMPTEST2084 && transfer_params_[0] == 0.f) {
+  if (transfer_ == TransferID::SMPTEST2084) {
     result.transfer_params_[0] = sdr_white_level;
   } else if (transfer_ == TransferID::LINEAR_HDR) {
     result.transfer_ = TransferID::CUSTOM_HDR;

diff --git a/ui/gfx/color_space.h b/ui/gfx/color_space.h
index f541f701..08cf2ad 100644
--- a/ui/gfx/color_space.h
+++ b/ui/gfx/color_space.h

@@ -290,9 +290,9 @@
   // the caller but replacing the matrix and range with the given values.
   ColorSpace GetWithMatrixAndRange(MatrixID matrix, RangeID range) const;
 
-  // If this color space has a PQ or scRGB linear transfer function that did not
-  // specify an SDR white level, then return |this| with its SDR white level set
-  // to |sdr_white_level|. Otherwise return |this| unmodified.
+  // If this color space has a PQ or scRGB linear transfer function, then return
+  // |this| with its SDR white level set to |sdr_white_level|. Otherwise return
+  // |this| unmodified.
   ColorSpace GetWithSDRWhiteLevel(float sdr_white_level) const;
 
   // This will return nullptr for non-RGB spaces, spaces with non-FULL

diff --git a/ui/gfx/color_space_unittest.cc b/ui/gfx/color_space_unittest.cc
index 27700703..57a995c 100644
--- a/ui/gfx/color_space_unittest.cc
+++ b/ui/gfx/color_space_unittest.cc

@@ -329,6 +329,12 @@
   EXPECT_EQ(color_space.GetTransferID(), ColorSpace::TransferID::SMPTEST2084);
   EXPECT_TRUE(color_space.GetPQSDRWhiteLevel(&sdr_white_level));
   EXPECT_EQ(sdr_white_level, kCustomWhiteLevel);
+
+  constexpr float kCustomWhiteLevel2 = kCustomWhiteLevel * 2;
+  color_space = color_space.GetWithSDRWhiteLevel(kCustomWhiteLevel2);
+  EXPECT_EQ(color_space.GetTransferID(), ColorSpace::TransferID::SMPTEST2084);
+  EXPECT_TRUE(color_space.GetPQSDRWhiteLevel(&sdr_white_level));
+  EXPECT_EQ(sdr_white_level, kCustomWhiteLevel2);
 }
 
 TEST(ColorSpace, LinearHDRWhiteLevel) {

diff --git a/ui/gl/gl_switches.cc b/ui/gl/gl_switches.cc
index 21b17115..d44a516 100644
--- a/ui/gl/gl_switches.cc
+++ b/ui/gl/gl_switches.cc

@@ -147,6 +147,11 @@
 // only used on Windows, as LUID is a Windows specific structure.
 const char kUseAdapterLuid[] = "use-adapter-luid";
 
+// Enable kDirectCompositionForceFullDamage feature regardless of overlay
+// support.
+const char kDirectCompositionForceFullDamageForTesting[] =
+    "direct-composition-force-full-damage-for-testing";
+
 // This is the list of switches passed from this file that are passed from the
 // GpuProcessHost to the GPU Process. Add your switch to this list if you need
 // to read it in the GPU process, else don't add it.
@@ -167,6 +172,7 @@
     kDisableDirectComposition,
     kEnableDirectCompositionVideoOverlays,
     kDisableDirectCompositionVideoOverlays,
+    kDirectCompositionForceFullDamageForTesting,
 };
 const int kGLSwitchesCopiedFromGpuProcessHostNumSwitches =
     base::size(kGLSwitchesCopiedFromGpuProcessHost);

diff --git a/ui/gl/gl_switches.h b/ui/gl/gl_switches.h
index 17b6f3f..a9ec45a 100644
--- a/ui/gl/gl_switches.h
+++ b/ui/gl/gl_switches.h

@@ -73,6 +73,8 @@
 GL_EXPORT extern const char kDisableDirectCompositionVideoOverlays[];
 GL_EXPORT extern const char kUseAdapterLuid[];
 
+GL_EXPORT extern const char kDirectCompositionForceFullDamageForTesting[];
+
 // These flags are used by the test harness code, not passed in by users.
 GL_EXPORT extern const char kDisableGLDrawingForTests[];
 GL_EXPORT extern const char kOverrideUseSoftwareGLForTests[];

diff --git a/ui/gl/gl_utils.cc b/ui/gl/gl_utils.cc
index f8a494b0..165216c 100644
--- a/ui/gl/gl_utils.cc
+++ b/ui/gl/gl_utils.cc

@@ -6,6 +6,7 @@
 
 #include "ui/gl/gl_utils.h"
 
+#include "base/command_line.h"
 #include "base/debug/alias.h"
 #include "base/logging.h"
 #include "ui/gl/gl_bindings.h"
@@ -119,6 +120,11 @@
 
 bool ShouldForceDirectCompositionRootSurfaceFullDamage() {
   static bool should_force = []() {
+    const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
+    if (cmd_line->HasSwitch(
+            switches::kDirectCompositionForceFullDamageForTesting)) {
+      return true;
+    }
     if (!base::FeatureList::IsEnabled(
             features::kDirectCompositionForceFullDamage)) {
       return false;

diff --git a/ui/views/accessibility/ax_tree_source_views.h b/ui/views/accessibility/ax_tree_source_views.h
index 37317b5..a867cd97 100644
--- a/ui/views/accessibility/ax_tree_source_views.h
+++ b/ui/views/accessibility/ax_tree_source_views.h

@@ -61,6 +61,8 @@
   // Useful for debugging.
   std::string ToString(views::AXAuraObjWrapper* root, std::string prefix);
 
+  const ui::AXTreeID tree_id_for_test() const { return tree_id_; }
+
  private:
   // The top-level object to use for the AX tree. See class comment.
   AXAuraObjWrapper* const root_ = nullptr;

diff --git a/ui/views/accessibility/ax_window_obj_wrapper.cc b/ui/views/accessibility/ax_window_obj_wrapper.cc
index bc23c39..bdbe0ec 100644
--- a/ui/views/accessibility/ax_window_obj_wrapper.cc
+++ b/ui/views/accessibility/ax_window_obj_wrapper.cc

@@ -144,8 +144,12 @@
     //
     // To avoid this double-parenting, only add the child tree ID of this
     // window if the top-level window doesn't have an associated Widget.
+    //
+    // Also, if this window is not visible, its child tree should also be
+    // non-visible so prune it.
     if (!window_->GetToplevelWindow() ||
-        GetWidgetForWindow(window_->GetToplevelWindow())) {
+        GetWidgetForWindow(window_->GetToplevelWindow()) ||
+        !window_->IsVisible()) {
       return;
     }
 

diff --git a/ui/webui/resources/cr_elements/BUILD.gn b/ui/webui/resources/cr_elements/BUILD.gn
index a32aa0e..a858d4c 100644
--- a/ui/webui/resources/cr_elements/BUILD.gn
+++ b/ui/webui/resources/cr_elements/BUILD.gn

@@ -3,6 +3,7 @@
 # found in the LICENSE file.
 
 import("//third_party/closure_compiler/compile_js.gni")
+import("//tools/polymer/html_to_js.gni")
 import("//tools/polymer/polymer.gni")
 import("//ui/webui/resources/tools/js_modulizer.gni")
 
@@ -163,6 +164,7 @@
     ":search_highlight_style_css_module",
     ":shared_style_css_module",
     ":shared_vars_css_module",
+    ":web_components",
     "cr_action_menu:cr_action_menu_module",
     "cr_button:cr_button_module",
     "cr_checkbox:cr_checkbox_module",
@@ -224,3 +226,10 @@
   ]
   extra_deps = [ ":modulize" ]
 }
+
+html_to_js("web_components") {
+  js_files = [
+    "mwb_shared_style.js",
+    "mwb_shared_vars.js",
+  ]
+}

diff --git a/ui/webui/resources/cr_elements/mwb_shared_style.html b/ui/webui/resources/cr_elements/mwb_shared_style.html
new file mode 100644
index 0000000..2fc0b95
--- /dev/null
+++ b/ui/webui/resources/cr_elements/mwb_shared_style.html

@@ -0,0 +1,47 @@
+<template>
+  <style>
+    ::-webkit-scrollbar-thumb {
+      background: var(--google-grey-refresh-300);
+    }
+
+    /* TODO(crbug.com/1110109): Add WCAG compliant dark mode support. */
+    @media (prefers-color-scheme: dark) {
+      ::-webkit-scrollbar-thumb {
+        background: var(--google-grey-refresh-500);
+      }
+    }
+
+    ::-webkit-scrollbar-thumb:hover {
+      background: var(--google-grey-refresh-500);
+    }
+
+    @media (prefers-color-scheme: dark) {
+      ::-webkit-scrollbar-thumb:hover {
+        background: var(--google-grey-refresh-300);
+      }
+    }
+
+    ::-webkit-scrollbar-track {
+      background: var(--tab-search-background-color);
+    }
+
+    ::-webkit-scrollbar {
+      width: 4px;
+    }
+
+    .mwb-list-item {
+      align-items: center;
+      background-color: var(--mwb-background-color);
+      display: flex;
+      padding: calc(var(--mwb-list-item-vertical-margin)/2) var(--mwb-list-item-horizontal-margin);
+    }
+
+    .mwb-list-item:hover {
+      background-color: var(--mwb-list-item-hover-background-color);
+    }
+
+    .mwb-list-item.selected {
+      background-color: var(--mwb-list-item-selected-background-color);
+    }
+  </style>
+</template>
\ No newline at end of file

diff --git a/ui/webui/resources/cr_elements/mwb_shared_style.js b/ui/webui/resources/cr_elements/mwb_shared_style.js
new file mode 100644
index 0000000..b02a14b
--- /dev/null
+++ b/ui/webui/resources/cr_elements/mwb_shared_style.js

@@ -0,0 +1,12 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'chrome://resources/cr_elements/shared_vars_css.m.js';
+import 'chrome://resources/cr_elements/mwb_shared_vars.js';
+
+const template = document.createElement('template');
+template.innerHTML = `
+<dom-module id="mwb-shared-style">{__html_template__}</dom-module>
+`;
+document.body.appendChild(template.content.cloneNode(true));
\ No newline at end of file

diff --git a/ui/webui/resources/cr_elements/mwb_shared_vars.html b/ui/webui/resources/cr_elements/mwb_shared_vars.html
new file mode 100644
index 0000000..189f52c3
--- /dev/null
+++ b/ui/webui/resources/cr_elements/mwb_shared_vars.html

@@ -0,0 +1,22 @@
+<custom-style>
+  <style>
+    html {
+      --mwb-background-color: white;
+      --mwb-icon-size: 16px;
+      --mwb-list-item-horizontal-margin: 8px;
+      --mwb-list-item-hover-background-color: rgba(var(--google-grey-900-rgb), 0.1);
+      --mwb-list-item-selected-background-color: rgba(var(--google-grey-900-rgb), 0.16);
+      --mwb-list-item-vertical-margin: 12px;
+      --mwb-primary-text-font-size: 13px;
+      --mwb-secondary-text-font-size: 12px;
+    }
+
+    @media (prefers-color-scheme: dark) {
+      html {
+        --mwb-background-color: var(--google-grey-900);
+        --mwb-list-item-hover-background-color: var(--google-grey-800);
+        --mwb-list-item-selected-background-color: var(--google-grey-refresh-700);
+      }
+    }
+  </style>
+</custom-style>

diff --git a/ui/webui/resources/cr_elements/mwb_shared_vars.js b/ui/webui/resources/cr_elements/mwb_shared_vars.js
new file mode 100644
index 0000000..a904775b
--- /dev/null
+++ b/ui/webui/resources/cr_elements/mwb_shared_vars.js

@@ -0,0 +1,10 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'chrome://resources/polymer/v3_0/polymer/polymer_bundled.min.js';
+import 'chrome://resources/cr_elements/shared_vars_css.m.js';
+
+const $_documentContainer = document.createElement('template');
+$_documentContainer.innerHTML = `{__html_template__}`;
+document.head.appendChild($_documentContainer.content);

diff --git a/ui/webui/resources/cr_elements_resources_v3.grdp b/ui/webui/resources/cr_elements_resources_v3.grdp
index 45ded9f6..bf6b0d3 100644
--- a/ui/webui/resources/cr_elements_resources_v3.grdp
+++ b/ui/webui/resources/cr_elements_resources_v3.grdp

@@ -184,6 +184,14 @@
          file="${root_gen_dir}/ui/webui/resources/cr_elements/md_select_css.m.js"
          use_base_dir="false"
          type="BINDATA" />
+  <include name="IDR_CR_ELEMENTS_MWB_SHARED_STYLE_JS"
+         file="${root_gen_dir}/ui/webui/resources/cr_elements/mwb_shared_style.js"
+         use_base_dir="false"
+         type="BINDATA" />
+  <include name="IDR_CR_ELEMENTS_MWB_SHARED_VARS_JS"
+         file="${root_gen_dir}/ui/webui/resources/cr_elements/mwb_shared_vars.js"
+         use_base_dir="false"
+         type="BINDATA" />
   <include name="IDR_CR_ELEMENTS_HIDDEN_STYLE_CSS_M_JS"
          file="${root_gen_dir}/ui/webui/resources/cr_elements/hidden_style_css.m.js"
          use_base_dir="false"