Update to Chromium version 76.0.3809.0 (#665002)

OSR tests will be fixed by a follow-up merge of Viz support (see issue #2575).

tests/cefclient/browser/osr_accessibility_node_win.cc

@@ -123,9 +123,9 @@ static inline int MiddleY(const CefRect& rect) {
 struct CefIAccessible : public IAccessible {
  public:
   // Implement IUnknown
-  STDMETHODIMP QueryInterface(REFIID riid, void** ppvObject);
-  STDMETHODIMP_(ULONG) AddRef();
-  STDMETHODIMP_(ULONG) Release();
+  STDMETHODIMP QueryInterface(REFIID riid, void** ppvObject) override;
+  STDMETHODIMP_(ULONG) AddRef() override;
+  STDMETHODIMP_(ULONG) Release() override;
 
   //
   // IAccessible methods.
@@ -196,15 +196,15 @@ struct CefIAccessible : public IAccessible {
   STDMETHODIMP put_accName(VARIANT var_id, BSTR put_name) override;
 
   // Implement IDispatch
-  STDMETHODIMP GetTypeInfoCount(unsigned int FAR* pctinfo);
+  STDMETHODIMP GetTypeInfoCount(unsigned int FAR* pctinfo) override;
   STDMETHODIMP GetTypeInfo(unsigned int iTInfo,
                            LCID lcid,
-                           ITypeInfo FAR* FAR* ppTInfo);
+                           ITypeInfo FAR* FAR* ppTInfo) override;
   STDMETHODIMP GetIDsOfNames(REFIID riid,
                              OLECHAR FAR* FAR* rgszNames,
                              unsigned int cNames,
                              LCID lcid,
-                             DISPID FAR* rgDispId);
+                             DISPID FAR* rgDispId) override;
   STDMETHODIMP Invoke(DISPID dispIdMember,
                       REFIID riid,
                       LCID lcid,
@@ -212,7 +212,7 @@ struct CefIAccessible : public IAccessible {
                       DISPPARAMS FAR* pDispParams,
                       VARIANT FAR* pVarResult,
                       EXCEPINFO FAR* pExcepInfo,
-                      unsigned int FAR* puArgErr);
+                      unsigned int FAR* puArgErr) override;
 
   CefIAccessible(OsrAXNode* node) : ref_count_(0), node_(node) {}
 

tests/cefclient/browser/views_menu_bar.cc

@@ -76,7 +76,7 @@ CefRefPtr<CefMenuModel> ViewsMenuBar::CreateMenuModel(const CefString& label,
 
   // Create the new MenuButton.
   CefRefPtr<CefMenuButton> button =
-      CefMenuButton::CreateMenuButton(this, label, false);
+      CefMenuButton::CreateMenuButton(this, label);
   button->SetID(new_menu_id);
   views_style::ApplyTo(button.get());
   button->SetInkDropEnabled(true);

tests/cefclient/browser/views_window.cc

@@ -719,23 +719,13 @@ void ViewsWindow::CreateMenuModel() {
 CefRefPtr<CefLabelButton> ViewsWindow::CreateBrowseButton(
     const std::string& label,
     int id) {
-  // The default framed button image resources (IDR_BUTTON_*) look pretty bad
-  // with non-default background colors, so we'll use frameless buttons with
-  // ink drop when a background color is specified.
-  const bool with_frame = !views_style::IsSet();
 
   CefRefPtr<CefLabelButton> button =
-      CefLabelButton::CreateLabelButton(this, label, with_frame);
+      CefLabelButton::CreateLabelButton(this, label);
   button->SetID(id);
   button->SetEnabled(false);    // Disabled by default.
   button->SetFocusable(false);  // Don't give focus to the button.
 
-  if (!with_frame) {
-    views_style::ApplyTo(button);
-    button->SetInkDropEnabled(true);
-    button->SetHorizontalAlignment(CEF_HORIZONTAL_ALIGNMENT_CENTER);
-  }
-
   return button;
 }
 
@@ -762,7 +752,7 @@ void ViewsWindow::AddControls() {
 
   // Create the menu button.
   CefRefPtr<CefMenuButton> menu_button =
-      CefMenuButton::CreateMenuButton(this, CefString(), false);
+      CefMenuButton::CreateMenuButton(this, CefString());
   menu_button->SetID(ID_MENU_BUTTON);
   menu_button->SetImage(
       CEF_BUTTON_STATE_NORMAL,
@@ -907,7 +897,7 @@ void ViewsWindow::UpdateExtensionControls() {
   for (int id = ID_EXTENSION_BUTTON_FIRST;
        it != extensions_.end() && id <= ID_EXTENSION_BUTTON_LAST; ++id, ++it) {
     CefRefPtr<CefMenuButton> button =
-        CefMenuButton::CreateMenuButton(this, CefString(), false);
+        CefMenuButton::CreateMenuButton(this, CefString());
     button->SetID(id);
     button->SetImage(CEF_BUTTON_STATE_NORMAL, (*it).image_);
     views_style::ApplyTo(button.get());

tests/ceftests/audio_output_unittest.cc

@@ -6,6 +6,9 @@
 #include "include/wrapper/cef_closure_task.h"
 #include "tests/ceftests/test_handler.h"
 #include "tests/gtest/include/gtest/gtest.h"
+#include "tests/shared/browser/client_app_browser.h"
+
+using client::ClientAppBrowser;
 
 namespace {
 
@@ -800,6 +803,22 @@ const char kTestHtml[] =
     "x5+fm5nB6slBlZ3Fcha363d5ut7u3ni1rLoPf728l3KcK\" allow=\"autoplay\" "
     "style=\"display:none\"></iframe></body></html>";
 
+class AudioOutputTest : public ClientAppBrowser::Delegate {
+ public:
+  AudioOutputTest() {}
+
+  void OnBeforeCommandLineProcessing(
+      CefRefPtr<ClientAppBrowser> app,
+      CefRefPtr<CefCommandLine> command_line) override {
+    // Allow media to autoplay without requiring user interaction.
+    command_line->AppendSwitchWithValue("autoplay-policy",
+                                        "no-user-gesture-required");
+  }
+
+ protected:
+  IMPLEMENT_REFCOUNTING(AudioOutputTest);
+};
+
 // a common base class for audio output tests
 class AudioOutputTestHandler : public TestHandler, public CefAudioHandler {
  public:
@@ -893,3 +912,9 @@ TEST(AudioOutputTest, AudioOutputTest) {
   handler->ExecuteTest();
   ReleaseAndWaitForDestructor(handler);
 }
+
+// Entry point for creating audio output test objects.
+// Called from client_app_delegates.cc.
+void CreateAudioOutputTests(ClientAppBrowser::DelegateSet& delegates) {
+  delegates.insert(new AudioOutputTest);
+}

tests/ceftests/client_app_delegates.cc

@@ -37,6 +37,10 @@ void CreateBrowserDelegates(ClientAppBrowser::DelegateSet& delegates) {
   // Bring in the V8 tests.
   extern void CreateV8BrowserTests(ClientAppBrowser::DelegateSet & delegates);
   CreateV8BrowserTests(delegates);
+
+  // Bring in audio output tests.
+  extern void CreateAudioOutputTests(ClientAppBrowser::DelegateSet & delegates);
+  CreateAudioOutputTests(delegates);
 }
 
 void CreateRenderDelegates(ClientAppRenderer::DelegateSet& delegates) {

tests/ceftests/scheme_handler_unittest.cc

@@ -36,11 +36,14 @@ class TestResults {
     got_request.reset();
     got_read.reset();
     got_output.reset();
+    got_sub_output.reset();
     got_redirect.reset();
     got_error.reset();
+    got_sub_error.reset();
     got_sub_request.reset();
     got_sub_read.reset();
     got_sub_success.reset();
+    got_exit_request.reset();
   }
 
   std::string url;
@@ -69,8 +72,9 @@ class TestResults {
   // Delay for returning scheme handler results.
   int delay;
 
-  TrackCallback got_request, got_read, got_output, got_redirect, got_error,
-      got_sub_redirect, got_sub_request, got_sub_read, got_sub_success;
+  TrackCallback got_request, got_read, got_output, got_sub_output, got_redirect,
+      got_error, got_sub_error, got_sub_redirect, got_sub_request, got_sub_read,
+      got_sub_success, got_exit_request;
 };
 
 // Current scheme handler object. Used when destroying the test from
@@ -102,18 +106,41 @@ class TestSchemeHandler : public TestHandler {
   // ClientSchemeHandler::ProcessRequest().
   void DestroyTest() override { TestHandler::DestroyTest(); }
 
+  void DestroyTestIfDone() {
+    if (!test_results_->exit_url.empty() && !test_results_->got_exit_request) {
+      return;
+    }
+
+    if (!test_results_->sub_url.empty() &&
+        !(test_results_->got_sub_output || test_results_->got_sub_error ||
+          test_results_->got_exit_request)) {
+      return;
+    }
+
+    if (!(test_results_->got_output || test_results_->got_error)) {
+      return;
+    }
+
+    DestroyTest();
+  }
+
+  bool IsExitURL(const std::string& url) const {
+    return !test_results_->exit_url.empty() &&
+           url.find(test_results_->exit_url) != std::string::npos;
+  }
+
   cef_return_value_t OnBeforeResourceLoad(
       CefRefPtr<CefBrowser> browser,
       CefRefPtr<CefFrame> frame,
       CefRefPtr<CefRequest> request,
       CefRefPtr<CefRequestCallback> callback) override {
-    std::string newUrl = request->GetURL();
-    if (!test_results_->exit_url.empty() &&
-        newUrl.find(test_results_->exit_url) != std::string::npos) {
+    const std::string& newUrl = request->GetURL();
+    if (IsExitURL(newUrl)) {
+      test_results_->got_exit_request.yes();
       // XHR tests use an exit URL to destroy the test.
       if (newUrl.find("SUCCESS") != std::string::npos)
         test_results_->got_sub_success.yes();
-      DestroyTest();
+      DestroyTestIfDone();
       return RV_CANCEL;
     }
 
@@ -140,16 +167,20 @@ class TestSchemeHandler : public TestHandler {
   void OnLoadEnd(CefRefPtr<CefBrowser> browser,
                  CefRefPtr<CefFrame> frame,
                  int httpStatusCode) override {
-    std::string url = frame->GetURL();
-    if (url == test_results_->url || test_results_->status_code != 200) {
+    const std::string& url = frame->GetURL();
+    if (url == test_results_->url)
       test_results_->got_output.yes();
+    else if (url == test_results_->sub_url)
+      test_results_->got_sub_output.yes();
+    else if (IsExitURL(url))
+      return;
 
+    if (url == test_results_->url || test_results_->status_code != 200) {
       // Test that the status code is correct.
       EXPECT_EQ(httpStatusCode, test_results_->status_code);
-
-      if (test_results_->sub_url.empty())
-        DestroyTest();
     }
+
+    DestroyTestIfDone();
   }
 
   void OnLoadError(CefRefPtr<CefBrowser> browser,
@@ -157,14 +188,22 @@ class TestSchemeHandler : public TestHandler {
                    ErrorCode errorCode,
                    const CefString& errorText,
                    const CefString& failedUrl) override {
-    test_results_->got_error.yes();
+    const std::string& url = failedUrl;
+    if (url == test_results_->url)
+      test_results_->got_error.yes();
+    else if (url == test_results_->sub_url)
+      test_results_->got_sub_error.yes();
+    else if (IsExitURL(url))
+      return;
+
     // Tests sometimes also fail with ERR_ABORTED.
     if (!(test_results_->expected_error_code == 0 &&
           errorCode == ERR_ABORTED)) {
       EXPECT_EQ(test_results_->expected_error_code, errorCode)
           << failedUrl.ToString();
     }
-    DestroyTest();
+
+    DestroyTestIfDone();
   }
 
  protected:

tests/ceftests/urlrequest_unittest.cc

@@ -482,8 +482,9 @@ class RequestSchemeHandler : public CefResourceHandler {
       : settings_(settings), destroy_callback_(destroy_callback) {}
 
   ~RequestSchemeHandler() override {
-    if (IsNetworkServiceEnabled())
+    if (IsNetworkServiceEnabled()) {
       EXPECT_EQ(1, cancel_ct_);
+    }
 
     destroy_callback_.Run();
   }
@@ -564,8 +565,9 @@ class RequestRedirectSchemeHandler : public CefResourceHandler {
         destroy_callback_(destroy_callback) {}
 
   ~RequestRedirectSchemeHandler() override {
-    if (IsNetworkServiceEnabled())
+    if (IsNetworkServiceEnabled()) {
       EXPECT_EQ(1, cancel_ct_);
+    }
 
     destroy_callback_.Run();
   }

tests/ceftests/views/button_unittest.cc

@@ -115,40 +115,30 @@ class EmptyMenuButtonDelegate : public CefMenuButtonDelegate {
   DISALLOW_COPY_AND_ASSIGN(EmptyMenuButtonDelegate);
 };
 
-void LabelButtonStyle(bool with_frame) {
+void LabelButtonStyle() {
   CefRefPtr<CefLabelButton> button = CefLabelButton::CreateLabelButton(
-      new EmptyMenuButtonDelegate(), kButtonText, with_frame);
+      new EmptyMenuButtonDelegate(), kButtonText);
   VerifyLabelButtonStyle(button);
 }
 
-void LabelButtonStyleFramedImpl() {
-  LabelButtonStyle(true);
-}
-
 void LabelButtonStyleFramelessImpl() {
-  LabelButtonStyle(false);
+  LabelButtonStyle();
 }
 
-void MenuButtonStyle(bool with_frame) {
+void MenuButtonStyle() {
   CefRefPtr<CefMenuButton> button = CefMenuButton::CreateMenuButton(
-      new EmptyMenuButtonDelegate(), kButtonText, with_frame);
+      new EmptyMenuButtonDelegate(), kButtonText);
   VerifyMenuButtonStyle(button);
 }
 
-void MenuButtonStyleFramedImpl() {
-  MenuButtonStyle(true);
-}
-
 void MenuButtonStyleFramelessImpl() {
-  MenuButtonStyle(false);
+  MenuButtonStyle();
 }
 
 }  // namespace
 
 // Test Button getters/setters.
-BUTTON_TEST(LabelButtonStyleFramed)
 BUTTON_TEST(LabelButtonStyleFrameless)
-BUTTON_TEST(MenuButtonStyleFramed)
 BUTTON_TEST(MenuButtonStyleFrameless)
 
 namespace {
@@ -194,12 +184,11 @@ void AddImage(CefRefPtr<CefLabelButton> button) {
   button->SetImage(CEF_BUTTON_STATE_NORMAL, image);
 }
 
-void RunLabelButtonClick(bool with_frame,
-                         bool with_text,
+void RunLabelButtonClick(bool with_text,
                          bool with_image,
                          CefRefPtr<CefWindow> window) {
   CefRefPtr<CefLabelButton> button = CefLabelButton::CreateLabelButton(
-      new TestButtonDelegate(), with_text ? kButtonText : "", with_frame);
+      new TestButtonDelegate(), with_text ? kButtonText : "");
   button->SetID(kButtonID);
 
   EXPECT_TRUE(button->AsButton());
@@ -235,94 +224,53 @@ void RunLabelButtonClick(bool with_frame,
 void LabelButtonClick(CefRefPtr<CefWaitableEvent> event,
                       bool with_button_frame,
                       bool with_button_text,
-                      bool with_button_image,
-                      bool with_window_frame) {
+                      bool with_button_image) {
   TestWindowDelegate::Config config;
-  config.on_window_created = base::Bind(RunLabelButtonClick, with_button_frame,
-                                        with_button_text, with_button_image);
-  config.frameless = !with_window_frame;
+  config.on_window_created =
+      base::Bind(RunLabelButtonClick, with_button_text, with_button_image);
+  config.frameless = false;
   config.close_window = false;
   TestWindowDelegate::RunTest(event, config);
 }
 
-void LabelButtonClickFramedWithTextWithImageFramedWindowImpl(
-    CefRefPtr<CefWaitableEvent> event) {
-  LabelButtonClick(event, true, true, true, true);
-}
-
-void LabelButtonClickFramedWithTextNoImageFramedWindowImpl(
-    CefRefPtr<CefWaitableEvent> event) {
-  LabelButtonClick(event, true, true, false, true);
-}
-
 void LabelButtonClickFramedWithTextWithImageFramelessWindowImpl(
     CefRefPtr<CefWaitableEvent> event) {
-  LabelButtonClick(event, true, true, true, false);
+  LabelButtonClick(event, true, true, true);
 }
 
 void LabelButtonClickFramedWithTextNoImageFramelessWindowImpl(
     CefRefPtr<CefWaitableEvent> event) {
-  LabelButtonClick(event, true, true, false, false);
-}
-
-void LabelButtonClickFramedNoTextWithImageFramedWindowImpl(
-    CefRefPtr<CefWaitableEvent> event) {
-  LabelButtonClick(event, true, false, true, true);
-}
-
-void LabelButtonClickFramedNoTextNoImageFramedWindowImpl(
-    CefRefPtr<CefWaitableEvent> event) {
-  LabelButtonClick(event, true, false, false, true);
+  LabelButtonClick(event, true, true, false);
 }
 
 void LabelButtonClickFramedNoTextWithImageFramelessWindowImpl(
     CefRefPtr<CefWaitableEvent> event) {
-  LabelButtonClick(event, true, false, true, false);
+  LabelButtonClick(event, true, false, true);
 }
 
 void LabelButtonClickFramedNoTextNoImageFramelessWindowImpl(
     CefRefPtr<CefWaitableEvent> event) {
-  LabelButtonClick(event, true, false, false, false);
-}
-
-void LabelButtonClickFramelessWithTextWithImageFramedWindowImpl(
-    CefRefPtr<CefWaitableEvent> event) {
-  LabelButtonClick(event, false, true, true, true);
-}
-
-void LabelButtonClickFramelessWithTextNoImageFramedWindowImpl(
-    CefRefPtr<CefWaitableEvent> event) {
-  LabelButtonClick(event, false, true, false, true);
+  LabelButtonClick(event, true, false, false);
 }
 
 void LabelButtonClickFramelessWithTextWithImageFramelessWindowImpl(
     CefRefPtr<CefWaitableEvent> event) {
-  LabelButtonClick(event, false, true, true, false);
+  LabelButtonClick(event, false, true, true);
 }
 
 void LabelButtonClickFramelessWithTextNoImageFramelessWindowImpl(
     CefRefPtr<CefWaitableEvent> event) {
-  LabelButtonClick(event, false, true, false, false);
-}
-
-void LabelButtonClickFramelessNoTextWithImageFramedWindowImpl(
-    CefRefPtr<CefWaitableEvent> event) {
-  LabelButtonClick(event, false, false, true, true);
-}
-
-void LabelButtonClickFramelessNoTextNoImageFramedWindowImpl(
-    CefRefPtr<CefWaitableEvent> event) {
-  LabelButtonClick(event, false, false, false, true);
+  LabelButtonClick(event, false, true, false);
 }
 
 void LabelButtonClickFramelessNoTextWithImageFramelessWindowImpl(
     CefRefPtr<CefWaitableEvent> event) {
-  LabelButtonClick(event, false, false, true, false);
+  LabelButtonClick(event, false, false, true);
 }
 
 void LabelButtonClickFramelessNoTextNoImageFramelessWindowImpl(
     CefRefPtr<CefWaitableEvent> event) {
-  LabelButtonClick(event, false, false, false, false);
+  LabelButtonClick(event, false, false, false);
 }
 
 }  // namespace
@@ -330,20 +278,12 @@ void LabelButtonClickFramelessNoTextNoImageFramelessWindowImpl(
 // Test LabelButton functionality. This is primarily to exercise exposed CEF
 // APIs and is not intended to comprehensively test button-related behavior
 // (which we presume that Chromium is testing).
-BUTTON_TEST_ASYNC(LabelButtonClickFramedWithTextWithImageFramedWindow)
-BUTTON_TEST_ASYNC(LabelButtonClickFramedWithTextNoImageFramedWindow)
 BUTTON_TEST_ASYNC(LabelButtonClickFramedWithTextWithImageFramelessWindow)
 BUTTON_TEST_ASYNC(LabelButtonClickFramedWithTextNoImageFramelessWindow)
-BUTTON_TEST_ASYNC(LabelButtonClickFramedNoTextWithImageFramedWindow)
-BUTTON_TEST_ASYNC(LabelButtonClickFramedNoTextNoImageFramedWindow)
 BUTTON_TEST_ASYNC(LabelButtonClickFramedNoTextWithImageFramelessWindow)
 BUTTON_TEST_ASYNC(LabelButtonClickFramedNoTextNoImageFramelessWindow)
-BUTTON_TEST_ASYNC(LabelButtonClickFramelessWithTextWithImageFramedWindow)
-BUTTON_TEST_ASYNC(LabelButtonClickFramelessWithTextNoImageFramedWindow)
 BUTTON_TEST_ASYNC(LabelButtonClickFramelessWithTextWithImageFramelessWindow)
 BUTTON_TEST_ASYNC(LabelButtonClickFramelessWithTextNoImageFramelessWindow)
-BUTTON_TEST_ASYNC(LabelButtonClickFramelessNoTextWithImageFramedWindow)
-BUTTON_TEST_ASYNC(LabelButtonClickFramelessNoTextNoImageFramedWindow)
 BUTTON_TEST_ASYNC(LabelButtonClickFramelessNoTextWithImageFramelessWindow)
 BUTTON_TEST_ASYNC(LabelButtonClickFramelessNoTextNoImageFramelessWindow)
 
@@ -479,12 +419,11 @@ class TestMenuButtonDelegate : public CefMenuButtonDelegate,
   DISALLOW_COPY_AND_ASSIGN(TestMenuButtonDelegate);
 };
 
-void RunMenuButtonClick(bool with_frame,
-                        bool with_text,
+void RunMenuButtonClick(bool with_text,
                         bool with_image,
                         CefRefPtr<CefWindow> window) {
   CefRefPtr<CefMenuButton> button = CefMenuButton::CreateMenuButton(
-      new TestMenuButtonDelegate(), with_text ? kButtonText : "", with_frame);
+      new TestMenuButtonDelegate(), with_text ? kButtonText : "");
   button->SetID(kButtonID);
 
   EXPECT_TRUE(button->AsButton());
@@ -521,94 +460,53 @@ void RunMenuButtonClick(bool with_frame,
 void MenuButtonClick(CefRefPtr<CefWaitableEvent> event,
                      bool with_button_frame,
                      bool with_button_text,
-                     bool with_button_image,
-                     bool with_window_frame) {
+                     bool with_button_image) {
   TestWindowDelegate::Config config;
-  config.on_window_created = base::Bind(RunMenuButtonClick, with_button_frame,
-                                        with_button_text, with_button_image);
-  config.frameless = !with_window_frame;
+  config.on_window_created =
+      base::Bind(RunMenuButtonClick, with_button_text, with_button_image);
+  config.frameless = false;
   config.close_window = false;
   TestWindowDelegate::RunTest(event, config);
 }
 
-void MenuButtonClickFramedWithTextWithImageFramedWindowImpl(
-    CefRefPtr<CefWaitableEvent> event) {
-  MenuButtonClick(event, true, true, true, true);
-}
-
-void MenuButtonClickFramedWithTextNoImageFramedWindowImpl(
-    CefRefPtr<CefWaitableEvent> event) {
-  MenuButtonClick(event, true, true, false, true);
-}
-
 void MenuButtonClickFramedWithTextWithImageFramelessWindowImpl(
     CefRefPtr<CefWaitableEvent> event) {
-  MenuButtonClick(event, true, true, true, false);
+  MenuButtonClick(event, true, true, true);
 }
 
 void MenuButtonClickFramedWithTextNoImageFramelessWindowImpl(
     CefRefPtr<CefWaitableEvent> event) {
-  MenuButtonClick(event, true, true, false, false);
-}
-
-void MenuButtonClickFramedNoTextWithImageFramedWindowImpl(
-    CefRefPtr<CefWaitableEvent> event) {
-  MenuButtonClick(event, true, false, true, true);
-}
-
-void MenuButtonClickFramedNoTextNoImageFramedWindowImpl(
-    CefRefPtr<CefWaitableEvent> event) {
-  MenuButtonClick(event, true, false, false, true);
+  MenuButtonClick(event, true, true, false);
 }
 
 void MenuButtonClickFramedNoTextWithImageFramelessWindowImpl(
     CefRefPtr<CefWaitableEvent> event) {
-  MenuButtonClick(event, true, false, true, false);
+  MenuButtonClick(event, true, false, true);
 }
 
 void MenuButtonClickFramedNoTextNoImageFramelessWindowImpl(
     CefRefPtr<CefWaitableEvent> event) {
-  MenuButtonClick(event, true, false, false, false);
-}
-
-void MenuButtonClickFramelessWithTextWithImageFramedWindowImpl(
-    CefRefPtr<CefWaitableEvent> event) {
-  MenuButtonClick(event, false, true, true, true);
-}
-
-void MenuButtonClickFramelessWithTextNoImageFramedWindowImpl(
-    CefRefPtr<CefWaitableEvent> event) {
-  MenuButtonClick(event, false, true, false, true);
+  MenuButtonClick(event, true, false, false);
 }
 
 void MenuButtonClickFramelessWithTextWithImageFramelessWindowImpl(
     CefRefPtr<CefWaitableEvent> event) {
-  MenuButtonClick(event, false, true, true, false);
+  MenuButtonClick(event, false, true, true);
 }
 
 void MenuButtonClickFramelessWithTextNoImageFramelessWindowImpl(
     CefRefPtr<CefWaitableEvent> event) {
-  MenuButtonClick(event, false, true, false, false);
-}
-
-void MenuButtonClickFramelessNoTextWithImageFramedWindowImpl(
-    CefRefPtr<CefWaitableEvent> event) {
-  MenuButtonClick(event, false, false, true, true);
-}
-
-void MenuButtonClickFramelessNoTextNoImageFramedWindowImpl(
-    CefRefPtr<CefWaitableEvent> event) {
-  MenuButtonClick(event, false, false, false, true);
+  MenuButtonClick(event, false, true, false);
 }
 
 void MenuButtonClickFramelessNoTextWithImageFramelessWindowImpl(
     CefRefPtr<CefWaitableEvent> event) {
-  MenuButtonClick(event, false, false, true, false);
+  MenuButtonClick(event, false, false, true);
 }
 
 void MenuButtonClickFramelessNoTextNoImageFramelessWindowImpl(
     CefRefPtr<CefWaitableEvent> event) {
-  MenuButtonClick(event, false, false, false, false);
+  MenuButtonClick(event, false, false, false);
 }
 
 }  // namespace
@@ -616,20 +514,12 @@ void MenuButtonClickFramelessNoTextNoImageFramelessWindowImpl(
 // Test MenuButton functionality. This is primarily to exercise exposed CEF
 // APIs and is not intended to comprehensively test button-related behavior
 // (which we presume that Chromium is testing).
-BUTTON_TEST_ASYNC(MenuButtonClickFramedWithTextWithImageFramedWindow)
-BUTTON_TEST_ASYNC(MenuButtonClickFramedWithTextNoImageFramedWindow)
 BUTTON_TEST_ASYNC(MenuButtonClickFramedWithTextWithImageFramelessWindow)
 BUTTON_TEST_ASYNC(MenuButtonClickFramedWithTextNoImageFramelessWindow)
-BUTTON_TEST_ASYNC(MenuButtonClickFramedNoTextWithImageFramedWindow)
-BUTTON_TEST_ASYNC(MenuButtonClickFramedNoTextNoImageFramedWindow)
 BUTTON_TEST_ASYNC(MenuButtonClickFramedNoTextWithImageFramelessWindow)
 BUTTON_TEST_ASYNC(MenuButtonClickFramedNoTextNoImageFramelessWindow)
-BUTTON_TEST_ASYNC(MenuButtonClickFramelessWithTextWithImageFramedWindow)
-BUTTON_TEST_ASYNC(MenuButtonClickFramelessWithTextNoImageFramedWindow)
 BUTTON_TEST_ASYNC(MenuButtonClickFramelessWithTextWithImageFramelessWindow)
 BUTTON_TEST_ASYNC(MenuButtonClickFramelessWithTextNoImageFramelessWindow)
-BUTTON_TEST_ASYNC(MenuButtonClickFramelessNoTextWithImageFramedWindow)
-BUTTON_TEST_ASYNC(MenuButtonClickFramelessNoTextNoImageFramedWindow)
 BUTTON_TEST_ASYNC(MenuButtonClickFramelessNoTextWithImageFramelessWindow)
 BUTTON_TEST_ASYNC(MenuButtonClickFramelessNoTextNoImageFramelessWindow)
 
@@ -652,7 +542,7 @@ class TestMenuButtonCustomPopupDelegate : public CefMenuButtonDelegate,
     popup_window_->SetBounds(CefRect(screen_point.x, screen_point.y, 100, 100));
 
     CefRefPtr<CefLabelButton> button =
-        CefLabelButton::CreateLabelButton(this, "Button", true);
+        CefLabelButton::CreateLabelButton(this, "Button");
     button->SetFocusable(can_activate_);
     popup_window_->AddChildView(button);
 
@@ -715,7 +605,7 @@ class TestMenuButtonCustomPopupDelegate : public CefMenuButtonDelegate,
 void RunMenuButtonCustomPopupClick(bool can_activate,
                                    CefRefPtr<CefWindow> window) {
   CefRefPtr<CefMenuButton> button = CefMenuButton::CreateMenuButton(
-      new TestMenuButtonCustomPopupDelegate(can_activate), "Custom", true);
+      new TestMenuButtonCustomPopupDelegate(can_activate), "Custom");
   button->SetID(kButtonID);
 
   window->AddChildView(button);