Fix CEF 146 API changes in GTK handlers; exclude dpi_aware on Linux

linesight · claude · linesight · commit d5df42007f83 · 2026-04-20T17:14:34.000-07:00
- client_handler/CMakeLists.txt: exclude dpi_aware.cpp on non-Windows
  (it includes &lt;windows.h&gt; with no platform guard).

- dialog_handler_gtk.h/.cpp: sync to CEF 146 API —
  * OVERRIDE → override (macro removed in CEF 146)
  * OnFileDialog: add accept_extensions/accept_descriptions params,
    drop selected_accept_filter; update AddFilters to use pre-parsed data
  * Remove FILE_DIALOG_TYPE_MASK/OVERWRITEPROMPT/HIDEREADONLY (enum now)
  * Replace deprecated GTK_STOCK_* with plain string literals
  * CefFileDialogCallback::Continue now takes only file list (no index)
  * NULL → nullptr throughout

- print_handler_gtk.h/.cpp: sync to CEF 146 API —
  * OVERRIDE → override
  * GetPdfPaperSize: add CefRefPtr&lt;CefBrowser&gt; first parameter

Co-Authored-By: Claude Sonnet 4.6 &lt;noreply@anthropic.com&gt;
diff --git a/src/client_handler/CMakeLists.txt b/src/client_handler/CMakeLists.txt
@@ -10,6 +10,8 @@ foreach(_f IN LISTS _all_cpp)
     set(_skip FALSE)
     if(_name MATCHES "_win\\.cpp$" AND NOT WIN32)
         set(_skip TRUE)
+    elseif(_name STREQUAL "dpi_aware.cpp" AND NOT WIN32)
+        set(_skip TRUE)
     elseif(_name MATCHES "_linux\\.cpp$" AND NOT CMAKE_SYSTEM_NAME STREQUAL "Linux")
         set(_skip TRUE)
     elseif(_name MATCHES "_mac\\.(cpp|mm)$" AND NOT APPLE)
diff --git a/src/client_handler/dialog_handler_gtk.cpp b/src/client_handler/dialog_handler_gtk.cpp
@@ -30,64 +30,44 @@ std::string GetPromptText(GtkDialog* dialog) {
   return std::string();
 }
 
-std::string GetDescriptionFromMimeType(const std::string& mime_type) {
-  // Check for wild card mime types and return an appropriate description.
-  static const struct {
-    const char* mime_type;
-    const char* label;
-  } kWildCardMimeTypes[] = {
-      {"audio", "Audio Files"},
-      {"image", "Image Files"},
-      {"text", "Text Files"},
-      {"video", "Video Files"},
-  };
-
-  for (size_t i = 0;
-       i < sizeof(kWildCardMimeTypes) / sizeof(kWildCardMimeTypes[0]); ++i) {
-    if (mime_type == std::string(kWildCardMimeTypes[i].mime_type) + "/*")
-      return std::string(kWildCardMimeTypes[i].label);
+// Split |str| on |delim| and return the parts.
+std::vector<std::string> SplitString(const std::string& str, char delim) {
+  std::vector<std::string> result;
+  std::string token;
+  for (char c : str) {
+    if (c == delim) {
+      if (!token.empty())
+        result.push_back(token);
+      token.clear();
+    } else {
+      token += c;
+    }
   }
-
-  return std::string();
+  if (!token.empty())
+    result.push_back(token);
+  return result;
 }
 
 void AddFilters(GtkFileChooser* chooser,
                 const std::vector<CefString>& accept_filters,
+                const std::vector<CefString>& accept_extensions,
+                const std::vector<CefString>& accept_descriptions,
                 bool include_all_files,
                 std::vector<GtkFileFilter*>* filters) {
   bool has_filter = false;
 
-  for (size_t i = 0; i < accept_filters.size(); ++i) {
-    const std::string& filter = accept_filters[i];
+  for (size_t j = 0; j < accept_filters.size(); ++j) {
+    const std::string& filter = accept_filters[j];
     if (filter.empty())
       continue;
 
-    std::vector<std::string> extensions;
-    std::string description;
-
-    size_t sep_index = filter.find('|');
-    if (sep_index != std::string::npos) {
-      // Treat as a filter of the form "Filter Name|.ext1;.ext2;.ext3".
-      description = filter.substr(0, sep_index);
-
-      const std::string& exts = filter.substr(sep_index + 1);
-      size_t last = 0;
-      size_t size = exts.size();
-      for (size_t i = 0; i <= size; ++i) {
-        if (i == size || exts[i] == ';') {
-          std::string ext(exts, last, i - last);
-          if (!ext.empty() && ext[0] == '.')
-            extensions.push_back(ext);
-          last = i + 1;
-        }
-      }
-    } else if (filter[0] == '.') {
-      // Treat as an extension beginning with the '.' character.
-      extensions.push_back(filter);
-    } else {
-      // Otherwise convert mime type to one or more extensions.
-      description = GetDescriptionFromMimeType(filter);
+    // Use pre-parsed extensions when available.
+    std::vector<std::string> extensions =
+        SplitString(accept_extensions[j], ';');
+    std::string description = accept_descriptions[j];
 
+    if (extensions.empty()) {
+      // Fallback: convert MIME type to extensions.
       std::vector<CefString> ext;
       CefGetExtensionsForMimeType(filter, ext);
       for (size_t x = 0; x < ext.size(); ++x)
@@ -101,7 +81,9 @@ void AddFilters(GtkFileChooser* chooser,
 
     std::string ext_str;
     for (size_t x = 0; x < extensions.size(); ++x) {
-      const std::string& pattern = "*" + extensions[x];
+      std::string pattern = extensions[x];
+      if (pattern[0] != '*')
+        pattern = "*" + pattern;
       if (x != 0)
         ext_str += ";";
       ext_str += pattern;
@@ -133,34 +115,31 @@ void AddFilters(GtkFileChooser* chooser,
 
 }  // namespace
 
-ClientDialogHandlerGtk::ClientDialogHandlerGtk() : gtk_dialog_(NULL) {}
+ClientDialogHandlerGtk::ClientDialogHandlerGtk() : gtk_dialog_(nullptr) {}
 
 bool ClientDialogHandlerGtk::OnFileDialog(
     CefRefPtr<CefBrowser> browser,
     FileDialogMode mode,
     const CefString& title,
     const CefString& default_file_path,
     const std::vector<CefString>& accept_filters,
-    int selected_accept_filter,
+    const std::vector<CefString>& accept_extensions,
+    const std::vector<CefString>& accept_descriptions,
     CefRefPtr<CefFileDialogCallback> callback) {
   std::vector<CefString> files;
 
   GtkFileChooserAction action;
   const gchar* accept_button;
 
-  // Remove any modifier flags.
-  FileDialogMode mode_type =
-      static_cast<FileDialogMode>(mode & FILE_DIALOG_TYPE_MASK);
-
-  if (mode_type == FILE_DIALOG_OPEN || mode_type == FILE_DIALOG_OPEN_MULTIPLE) {
+  if (mode == FILE_DIALOG_OPEN || mode == FILE_DIALOG_OPEN_MULTIPLE) {
     action = GTK_FILE_CHOOSER_ACTION_OPEN;
-    accept_button = GTK_STOCK_OPEN;
-  } else if (mode_type == FILE_DIALOG_OPEN_FOLDER) {
+    accept_button = "_Open";
+  } else if (mode == FILE_DIALOG_OPEN_FOLDER) {
     action = GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER;
-    accept_button = GTK_STOCK_OPEN;
-  } else if (mode_type == FILE_DIALOG_SAVE) {
+    accept_button = "_Open";
+  } else if (mode == FILE_DIALOG_SAVE) {
     action = GTK_FILE_CHOOSER_ACTION_SAVE;
-    accept_button = GTK_STOCK_SAVE;
+    accept_button = "_Save";
   } else {
     NOTREACHED();
     return false;
@@ -170,7 +149,7 @@ bool ClientDialogHandlerGtk::OnFileDialog(
   if (!title.empty()) {
     title_str = title;
   } else {
-    switch (mode_type) {
+    switch (mode) {
       case FILE_DIALOG_OPEN:
         title_str = "Open File";
         break;
@@ -193,21 +172,13 @@ bool ClientDialogHandlerGtk::OnFileDialog(
     return false;
 
   GtkWidget* dialog = gtk_file_chooser_dialog_new(
-      title_str.c_str(), GTK_WINDOW(window), action, GTK_STOCK_CANCEL,
-      GTK_RESPONSE_CANCEL, accept_button, GTK_RESPONSE_ACCEPT, NULL);
+      title_str.c_str(), GTK_WINDOW(window), action, "_Cancel",
+      GTK_RESPONSE_CANCEL, accept_button, GTK_RESPONSE_ACCEPT, nullptr);
 
-  if (mode_type == FILE_DIALOG_OPEN_MULTIPLE)
+  if (mode == FILE_DIALOG_OPEN_MULTIPLE)
     gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), TRUE);
 
-  if (mode_type == FILE_DIALOG_SAVE) {
-    gtk_file_chooser_set_do_overwrite_confirmation(
-        GTK_FILE_CHOOSER(dialog), !!(mode & FILE_DIALOG_OVERWRITEPROMPT_FLAG));
-  }
-
-  gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(dialog),
-                                   !(mode & FILE_DIALOG_HIDEREADONLY_FLAG));
-
-  if (!default_file_path.empty() && mode_type == FILE_DIALOG_SAVE) {
+  if (!default_file_path.empty() && mode == FILE_DIALOG_SAVE) {
     const std::string& file_path = default_file_path;
     bool exists = false;
 
@@ -227,25 +198,22 @@ bool ClientDialogHandlerGtk::OnFileDialog(
   }
 
   std::vector<GtkFileFilter*> filters;
-  AddFilters(GTK_FILE_CHOOSER(dialog), accept_filters, true, &filters);
-  if (selected_accept_filter < static_cast<int>(filters.size())) {
-    gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog),
-                                filters[selected_accept_filter]);
-  }
+  AddFilters(GTK_FILE_CHOOSER(dialog), accept_filters, accept_extensions,
+             accept_descriptions, true, &filters);
 
   bool success = false;
 
   if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
-    if (mode_type == FILE_DIALOG_OPEN || mode_type == FILE_DIALOG_OPEN_FOLDER ||
-        mode_type == FILE_DIALOG_SAVE) {
+    if (mode == FILE_DIALOG_OPEN || mode == FILE_DIALOG_OPEN_FOLDER ||
+        mode == FILE_DIALOG_SAVE) {
       char* filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
       files.push_back(std::string(filename));
       success = true;
-    } else if (mode_type == FILE_DIALOG_OPEN_MULTIPLE) {
+    } else if (mode == FILE_DIALOG_OPEN_MULTIPLE) {
       GSList* filenames =
           gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dialog));
       if (filenames) {
-        for (GSList* iter = filenames; iter != NULL;
+        for (GSList* iter = filenames; iter != nullptr;
              iter = g_slist_next(iter)) {
           std::string path(static_cast<char*>(iter->data));
           g_free(iter->data);
@@ -257,24 +225,10 @@ bool ClientDialogHandlerGtk::OnFileDialog(
     }
   }
 
-  int filter_index = selected_accept_filter;
-  if (success) {
-    GtkFileFilter* selected_filter =
-        gtk_file_chooser_get_filter(GTK_FILE_CHOOSER(dialog));
-    if (selected_filter != NULL) {
-      for (size_t x = 0; x < filters.size(); ++x) {
-        if (filters[x] == selected_filter) {
-          filter_index = x;
-          break;
-        }
-      }
-    }
-  }
-
   gtk_widget_destroy(dialog);
 
   if (success)
-    callback->Continue(filter_index, files);
+    callback->Continue(files);
   else
     callback->Cancel();
 
@@ -316,11 +270,6 @@ bool ClientDialogHandlerGtk::OnJSDialog(CefRefPtr<CefBrowser> browser,
 
   js_dialog_callback_ = callback;
 
-  if (!origin_url.empty()) {
-    // title += " - ";
-    // title += CefFormatUrlForSecurityDisplay(origin_url).ToString();
-  }
-
   GtkWindow* window = CefBrowser_GetGtkWindow(browser);
   if (!window)
     return false;
@@ -329,12 +278,12 @@ bool ClientDialogHandlerGtk::OnJSDialog(CefRefPtr<CefBrowser> browser,
                                        gtk_message_type, buttons, "%s",
                                        message_text.ToString().c_str());
   g_signal_connect(gtk_dialog_, "delete-event",
-                   G_CALLBACK(gtk_widget_hide_on_delete), NULL);
+                   G_CALLBACK(gtk_widget_hide_on_delete), nullptr);
 
   gtk_window_set_title(GTK_WINDOW(gtk_dialog_), title.c_str());
 
   GtkWidget* ok_button = gtk_dialog_add_button(GTK_DIALOG(gtk_dialog_),
-                                               GTK_STOCK_OK, GTK_RESPONSE_OK);
+                                               "_OK", GTK_RESPONSE_OK);
 
   if (dialog_type != JSDIALOGTYPE_PROMPT)
     gtk_widget_grab_focus(ok_button);
@@ -378,8 +327,8 @@ void ClientDialogHandlerGtk::OnResetDialogState(CefRefPtr<CefBrowser> browser) {
   if (!gtk_dialog_)
     return;
   gtk_widget_destroy(gtk_dialog_);
-  gtk_dialog_ = NULL;
-  js_dialog_callback_ = NULL;
+  gtk_dialog_ = nullptr;
+  js_dialog_callback_ = nullptr;
 }
 
 // static
@@ -401,5 +350,5 @@ void ClientDialogHandlerGtk::OnDialogResponse(GtkDialog* dialog,
       NOTREACHED();
   }
 
-  handler->OnResetDialogState(NULL);
+  handler->OnResetDialogState(nullptr);
 }
diff --git a/src/client_handler/dialog_handler_gtk.h b/src/client_handler/dialog_handler_gtk.h
@@ -25,8 +25,9 @@ class ClientDialogHandlerGtk : public CefDialogHandler,
                     const CefString& title,
                     const CefString& default_file_path,
                     const std::vector<CefString>& accept_filters,
-                    int selected_accept_filter,
-                    CefRefPtr<CefFileDialogCallback> callback) OVERRIDE;
+                    const std::vector<CefString>& accept_extensions,
+                    const std::vector<CefString>& accept_descriptions,
+                    CefRefPtr<CefFileDialogCallback> callback) override;
 
   // CefJSDialogHandler methods.
   bool OnJSDialog(CefRefPtr<CefBrowser> browser,
@@ -35,12 +36,12 @@ class ClientDialogHandlerGtk : public CefDialogHandler,
                   const CefString& message_text,
                   const CefString& default_prompt_text,
                   CefRefPtr<CefJSDialogCallback> callback,
-                  bool& suppress_message) OVERRIDE;
+                  bool& suppress_message) override;
   bool OnBeforeUnloadDialog(CefRefPtr<CefBrowser> browser,
                             const CefString& message_text,
                             bool is_reload,
-                            CefRefPtr<CefJSDialogCallback> callback) OVERRIDE;
-  void OnResetDialogState(CefRefPtr<CefBrowser> browser) OVERRIDE;
+                            CefRefPtr<CefJSDialogCallback> callback) override;
+  void OnResetDialogState(CefRefPtr<CefBrowser> browser) override;
 
  private:
   static void OnDialogResponse(GtkDialog* dialog,
diff --git a/src/subprocess/print_handler_gtk.cpp b/src/subprocess/print_handler_gtk.cpp
@@ -599,7 +599,8 @@ void ClientPrintHandlerGtk::OnPrintReset(CefRefPtr<CefBrowser> browser) {
   print_handler_map_.erase(it);
 }
 
-CefSize ClientPrintHandlerGtk::GetPdfPaperSize(int device_units_per_inch) {
+CefSize ClientPrintHandlerGtk::GetPdfPaperSize(CefRefPtr<CefBrowser> browser,
+                                               int device_units_per_inch) {
   CEF_REQUIRE_UI_THREAD();
 
   GtkPageSetup* page_setup = gtk_page_setup_new();
diff --git a/src/subprocess/print_handler_gtk.h b/src/subprocess/print_handler_gtk.h
@@ -20,19 +20,20 @@ class ClientPrintHandlerGtk : public CefPrintHandler {
   virtual ~ClientPrintHandlerGtk();
 
   // CefPrintHandler methods.
-  void OnPrintStart(CefRefPtr<CefBrowser> browser) OVERRIDE;
+  void OnPrintStart(CefRefPtr<CefBrowser> browser) override;
   void OnPrintSettings(CefRefPtr<CefBrowser> browser,
                        CefRefPtr<CefPrintSettings> settings,
-                       bool get_defaults) OVERRIDE;
+                       bool get_defaults) override;
   bool OnPrintDialog(CefRefPtr<CefBrowser> browser,
                      bool has_selection,
-                     CefRefPtr<CefPrintDialogCallback> callback) OVERRIDE;
+                     CefRefPtr<CefPrintDialogCallback> callback) override;
   bool OnPrintJob(CefRefPtr<CefBrowser> browser,
                   const CefString& document_name,
                   const CefString& pdf_file_path,
-                  CefRefPtr<CefPrintJobCallback> callback) OVERRIDE;
-  void OnPrintReset(CefRefPtr<CefBrowser> browser) OVERRIDE;
-  CefSize GetPdfPaperSize(int device_units_per_inch) OVERRIDE;
+                  CefRefPtr<CefPrintJobCallback> callback) override;
+  void OnPrintReset(CefRefPtr<CefBrowser> browser) override;
+  CefSize GetPdfPaperSize(CefRefPtr<CefBrowser> browser,
+                          int device_units_per_inch) override;
 
  private:
   // Print handler.

Original file line number	Diff line number	Diff line change
`@@ -599,7 +599,8 @@ void ClientPrintHandlerGtk::OnPrintReset(CefRefPtr<CefBrowser> browser) {`
`599`	`599`	`print_handler_map_.erase(it);`
`600`	`600`	`}`
`601`	`601`
`602`		`-CefSize ClientPrintHandlerGtk::GetPdfPaperSize(int device_units_per_inch) {`
	`602`	`+CefSize ClientPrintHandlerGtk::GetPdfPaperSize(CefRefPtr<CefBrowser> browser,`
	`603`	`+ int device_units_per_inch) {`
`603`	`604`	`CEF_REQUIRE_UI_THREAD();`
`604`	`605`
`605`	`606`	`GtkPageSetup* page_setup = gtk_page_setup_new();`