mirrors/electron
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions

perf: use flat_set, flat_map for small, trivially-moved containers (#40817)

Browse source 
* refactor: use base::flat_map in ElectronMenuModel

* refactor: use base::flat_map in BuildSubmenuFromModel()

* refactor: use base::flat_map in GetDialogsMap()

* refactor: use base::flat_map in DesktopCapturer

* refactor: use base::flat_map, flat_set in ElectronBrowserClient

* refactor: use base::flat_map in ProxyingURLLoaderFactory

* refactor: use base::flat_map in MapToCommonId()

* refactor: use base::flat_map for g_map_id

* refactor: use base::flat_map for ViewsDelegate::AppbarAutohideEdgeMap

* refactor: use base::flat_map for App::app_metrics_

* refactor: use base::flat_map for PowerSaveBlocker::wake_lock_types_

* refactor: use base::flat_map for NativeImage::hicons_

* refactor: use base::flat_map for MenuViews::menu_runners_

* refactor: use base::flat_map for WebViewManager::web_contents_embedder_map_

* refactor: use base::flat_map for InspectableWebContents::extensions_api_

* refactor: use base::flat_set for libnotify GetServerCapabilities()

* refactor: use base::flat_set for InspectableWebContents::loaders_

* refactor: use base::flat_set for ElectronRendererClient::environments_

refactor: use base::flat_set for ElectronRendererClient::injected_frames_

* refactor: use base::flat_set for WebWorkerObserver::environments_
This commit is contained in:
Charles Kerr 2024-01-05 05:18:31 -06:00 committed by GitHub
parent 5086071294
commit 22970f573b
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
23 changed files with 83 additions and 87 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
shell/browser/api/electron_api_app.h
View file

@ -5,11 +5,11 @@
#ifndef ELECTRON_SHELL_BROWSER_API_ELECTRON_API_APP_H_ #ifndef ELECTRON_SHELL_BROWSER_API_ELECTRON_API_APP_H_
#define ELECTRON_SHELL_BROWSER_API_ELECTRON_API_APP_H_ #define ELECTRON_SHELL_BROWSER_API_ELECTRON_API_APP_H_
#include <map>
#include <memory> #include <memory>
#include <string> #include <string>
#include <vector> #include <vector>
#include "base/containers/flat_map.h"
#include "base/task/cancelable_task_tracker.h" #include "base/task/cancelable_task_tracker.h"
#include "chrome/browser/icon_manager.h" #include "chrome/browser/icon_manager.h"
#include "chrome/browser/process_singleton.h" #include "chrome/browser/process_singleton.h"
@ -259,9 +259,8 @@ class App : public ElectronBrowserClient::Delegate,
base::FilePath app_path_; base::FilePath app_path_;
using ProcessMetricMap = // pid -> electron::ProcessMetric
std::map<int, std::unique_ptr<electron::ProcessMetric>>; base::flat_map<int, std::unique_ptr<electron::ProcessMetric>> app_metrics_;
ProcessMetricMap app_metrics_;
bool disable_hw_acceleration_ = false; bool disable_hw_acceleration_ = false;
bool disable_domain_blocking_for_3DAPIs_ = false; bool disable_domain_blocking_for_3DAPIs_ = false;

15
shell/browser/api/electron_api_desktop_capturer.cc
View file

@ -4,11 +4,11 @@
#include "shell/browser/api/electron_api_desktop_capturer.h" #include "shell/browser/api/electron_api_desktop_capturer.h"
#include <map>
#include <memory> #include <memory>
#include <utility> #include <utility>
#include <vector> #include <vector>
#include "base/containers/flat_map.h"
#include "base/strings/string_number_conversions.h" #include "base/strings/string_number_conversions.h"
#include "base/strings/utf_string_conversions.h" #include "base/strings/utf_string_conversions.h"
#include "base/threading/thread_restrictions.h" #include "base/threading/thread_restrictions.h"
@ -42,11 +42,11 @@
#if BUILDFLAG(IS_LINUX) #if BUILDFLAG(IS_LINUX)
// Private function in ui/base/x/x11_display_util.cc // Private function in ui/base/x/x11_display_util.cc
std::map<x11::RandR::Output, int> GetMonitors( base::flat_map<x11::RandR::Output, int> GetMonitors(
std::pair<uint32_t, uint32_t> version, std::pair<uint32_t, uint32_t> version,
x11::RandR* randr, x11::RandR* randr,
x11::Window window) { x11::Window window) {
std::map<x11::RandR::Output, int> output_to_monitor; base::flat_map<x11::RandR::Output, int> output_to_monitor;
if (version >= std::pair<uint32_t, uint32_t>{1, 5}) { if (version >= std::pair<uint32_t, uint32_t>{1, 5}) {
if (auto reply = randr->GetMonitors({window}).Sync()) { if (auto reply = randr->GetMonitors({window}).Sync()) {
for (size_t monitor = 0; monitor < reply->monitors.size(); monitor++) { for (size_t monitor = 0; monitor < reply->monitors.size(); monitor++) {
@ -76,12 +76,12 @@ std::vector<uint8_t> GetEDIDProperty(x11::RandR* randr,
// Find the mapping from monitor name atom to the display identifier // Find the mapping from monitor name atom to the display identifier
// that the screen API uses. Based on the logic in BuildDisplaysFromXRandRInfo // that the screen API uses. Based on the logic in BuildDisplaysFromXRandRInfo
// in ui/base/x/x11_display_util.cc // in ui/base/x/x11_display_util.cc
std::map<int32_t, uint32_t> MonitorAtomIdToDisplayId() { base::flat_map<int32_t, uint32_t> MonitorAtomIdToDisplayId() {
auto* connection = x11::Connection::Get(); auto* connection = x11::Connection::Get();
auto& randr = connection->randr(); auto& randr = connection->randr();
auto x_root_window = ui::GetX11RootWindow(); auto x_root_window = ui::GetX11RootWindow();
std::map<int32_t, uint32_t> monitor_atom_to_display; base::flat_map<int32_t, uint32_t> monitor_atom_to_display;
auto resources = randr.GetScreenResourcesCurrent({x_root_window}).Sync(); auto resources = randr.GetScreenResourcesCurrent({x_root_window}).Sync();
if (!resources) { if (!resources) {
@ -89,7 +89,7 @@ std::map<int32_t, uint32_t> MonitorAtomIdToDisplayId() {
return monitor_atom_to_display; return monitor_atom_to_display;
} }
std::map<x11::RandR::Output, int> output_to_monitor = const auto output_to_monitor =
GetMonitors(connection->randr_version(), &randr, x_root_window); GetMonitors(connection->randr_version(), &randr, x_root_window);
auto monitors_reply = randr.GetMonitors({x_root_window}).Sync(); auto monitors_reply = randr.GetMonitors({x_root_window}).Sync();
@ -385,8 +385,7 @@ void DesktopCapturer::UpdateSourcesList(DesktopMediaList* list) {
// display name atom and the display id is either the EDID or the // display name atom and the display id is either the EDID or the
// loop index when that display was found (see // loop index when that display was found (see
// BuildDisplaysFromXRandRInfo in ui/base/x/x11_display_util.cc) // BuildDisplaysFromXRandRInfo in ui/base/x/x11_display_util.cc)
std::map<int32_t, uint32_t> monitor_atom_to_display_id = const auto monitor_atom_to_display_id = MonitorAtomIdToDisplayId();
MonitorAtomIdToDisplayId();
for (auto& source : screen_sources) { for (auto& source : screen_sources) {
auto display_id_iter = auto display_id_iter =
monitor_atom_to_display_id.find(source.media_list_source.id.id); monitor_atom_to_display_id.find(source.media_list_source.id.id);

28
shell/browser/api/electron_api_menu_views.cc
View file

@ -52,24 +52,26 @@ void MenuViews::PopupAt(BaseWindow* window,
auto close_callback = base::AdaptCallbackForRepeating( auto close_callback = base::AdaptCallbackForRepeating(
base::BindOnce(&MenuViews::OnClosed, weak_factory_.GetWeakPtr(), base::BindOnce(&MenuViews::OnClosed, weak_factory_.GetWeakPtr(),
window_id, std::move(callback_with_ref))); window_id, std::move(callback_with_ref)));
menu_runners_[window_id] = auto& runner = menu_runners_[window_id] =
std::make_unique<MenuRunner>(model(), flags, std::move(close_callback)); std::make_unique<MenuRunner>(model(), flags, std::move(close_callback));
menu_runners_[window_id]->RunMenuAt( runner->RunMenuAt(native_window->widget(), nullptr,
native_window->widget(), nullptr, gfx::Rect(location, gfx::Size()), gfx::Rect{location, gfx::Size{}},
views::MenuAnchorPosition::kTopLeft, source_type); views::MenuAnchorPosition::kTopLeft, source_type);
} }
void MenuViews::ClosePopupAt(int32_t window_id) { void MenuViews::ClosePopupAt(int32_t window_id) {
auto runner = menu_runners_.find(window_id); if (auto iter = menu_runners_.find(window_id); iter != menu_runners_.end()) {
if (runner != menu_runners_.end()) {
// Close the runner for the window. // Close the runner for the window.
runner->second->Cancel(); iter->second->Cancel();
} else if (window_id == -1) { return;
// Or just close all opened runners. }
for (auto it = menu_runners_.begin(); it != menu_runners_.end();) {
// The iterator is invalidated after the call. if (window_id == -1) {
(it++)->second->Cancel(); // When -1 is passed in, close all opened runners.
} // Note: `Cancel()` invalidaes iters, so move() to a temp before looping
auto tmp = std::move(menu_runners_);
for (auto& [id, runner] : tmp)
runner->Cancel();
} }
} }

4
shell/browser/api/electron_api_menu_views.h
View file

@ -5,9 +5,9 @@
#ifndef ELECTRON_SHELL_BROWSER_API_ELECTRON_API_MENU_VIEWS_H_ #ifndef ELECTRON_SHELL_BROWSER_API_ELECTRON_API_MENU_VIEWS_H_
#define ELECTRON_SHELL_BROWSER_API_ELECTRON_API_MENU_VIEWS_H_ #define ELECTRON_SHELL_BROWSER_API_ELECTRON_API_MENU_VIEWS_H_
#include <map>
#include <memory> #include <memory>
#include "base/containers/flat_map.h"
#include "base/memory/weak_ptr.h" #include "base/memory/weak_ptr.h"
#include "shell/browser/api/electron_api_menu.h" #include "shell/browser/api/electron_api_menu.h"
#include "ui/display/screen.h" #include "ui/display/screen.h"
@ -33,7 +33,7 @@ class MenuViews : public Menu {
void OnClosed(int32_t window_id, base::OnceClosure callback); void OnClosed(int32_t window_id, base::OnceClosure callback);
// window ID -> open context menu // window ID -> open context menu
std::map<int32_t, std::unique_ptr<views::MenuRunner>> menu_runners_; base::flat_map<int32_t, std::unique_ptr<views::MenuRunner>> menu_runners_;
base::WeakPtrFactory<MenuViews> weak_factory_{this}; base::WeakPtrFactory<MenuViews> weak_factory_{this};
}; };

6
shell/browser/api/electron_api_power_save_blocker.h
View file

@ -5,8 +5,7 @@
#ifndef ELECTRON_SHELL_BROWSER_API_ELECTRON_API_POWER_SAVE_BLOCKER_H_ #ifndef ELECTRON_SHELL_BROWSER_API_ELECTRON_API_POWER_SAVE_BLOCKER_H_
#define ELECTRON_SHELL_BROWSER_API_ELECTRON_API_POWER_SAVE_BLOCKER_H_ #define ELECTRON_SHELL_BROWSER_API_ELECTRON_API_POWER_SAVE_BLOCKER_H_
#include <map> #include "base/containers/flat_map.h"
#include "gin/handle.h" #include "gin/handle.h"
#include "gin/object_template_builder.h" #include "gin/object_template_builder.h"
#include "gin/wrappable.h" #include "gin/wrappable.h"
@ -48,8 +47,7 @@ class PowerSaveBlocker : public gin::Wrappable<PowerSaveBlocker> {
bool is_wake_lock_active_ = false; bool is_wake_lock_active_ = false;
// Map from id to the corresponding blocker type for each request. // Map from id to the corresponding blocker type for each request.
using WakeLockTypeMap = std::map<int, device::mojom::WakeLockType>; base::flat_map<int, device::mojom::WakeLockType> wake_lock_types_;
WakeLockTypeMap wake_lock_types_;
mojo::Remote<device::mojom::WakeLock> wake_lock_; mojo::Remote<device::mojom::WakeLock> wake_lock_;
}; };

4
shell/browser/api/electron_api_system_preferences_mac.mm
View file

@ -4,7 +4,6 @@
#include "shell/browser/api/electron_api_system_preferences.h" #include "shell/browser/api/electron_api_system_preferences.h"
#include <map>
#include <string> #include <string>
#include <utility> #include <utility>
@ -14,6 +13,7 @@
#import <Security/Security.h> #import <Security/Security.h>
#include "base/apple/scoped_cftyperef.h" #include "base/apple/scoped_cftyperef.h"
#include "base/containers/flat_map.h"
#include "base/strings/stringprintf.h" #include "base/strings/stringprintf.h"
#include "base/strings/sys_string_conversions.h" #include "base/strings/sys_string_conversions.h"
#include "base/task/sequenced_task_runner.h" #include "base/task/sequenced_task_runner.h"
@ -81,7 +81,7 @@ namespace {
int g_next_id = 0; int g_next_id = 0;
// The map to convert |id| to |int|. // The map to convert |id| to |int|.
std::map<int, id> g_id_map; base::flat_map<int, id> g_id_map;
AVMediaType ParseMediaType(const std::string& media_type) { AVMediaType ParseMediaType(const std::string& media_type) {
if (media_type == "camera") { if (media_type == "camera") {

8
shell/browser/electron_browser_client.h
View file

@ -5,12 +5,12 @@
#ifndef ELECTRON_SHELL_BROWSER_ELECTRON_BROWSER_CLIENT_H_ #ifndef ELECTRON_SHELL_BROWSER_ELECTRON_BROWSER_CLIENT_H_
#define ELECTRON_SHELL_BROWSER_ELECTRON_BROWSER_CLIENT_H_ #define ELECTRON_SHELL_BROWSER_ELECTRON_BROWSER_CLIENT_H_
#include <map>
#include <memory> #include <memory>
#include <set>
#include <string> #include <string>
#include <vector> #include <vector>
#include "base/containers/flat_map.h"
#include "base/containers/flat_set.h"
#include "base/files/file_path.h" #include "base/files/file_path.h"
#include "base/memory/raw_ptr.h" #include "base/memory/raw_ptr.h"
#include "base/synchronization/lock.h" #include "base/synchronization/lock.h"
@ -313,9 +313,9 @@ class ElectronBrowserClient : public content::ContentBrowserClient,
bool IsRendererSubFrame(int process_id) const; bool IsRendererSubFrame(int process_id) const;
// pending_render_process => web contents. // pending_render_process => web contents.
std::map<int, content::WebContents*> pending_processes_; base::flat_map<int, content::WebContents*> pending_processes_;
std::set<int> renderer_is_subframe_; base::flat_set<int> renderer_is_subframe_;
std::unique_ptr<PlatformNotificationService> notification_service_; std::unique_ptr<PlatformNotificationService> notification_service_;
std::unique_ptr<NotificationPresenter> notification_presenter_; std::unique_ptr<NotificationPresenter> notification_presenter_;

6
shell/browser/net/proxying_url_loader_factory.h
View file

@ -6,12 +6,12 @@
#define ELECTRON_SHELL_BROWSER_NET_PROXYING_URL_LOADER_FACTORY_H_ #define ELECTRON_SHELL_BROWSER_NET_PROXYING_URL_LOADER_FACTORY_H_
#include <cstdint> #include <cstdint>
#include <map>
#include <memory> #include <memory>
#include <set> #include <set>
#include <string> #include <string>
#include <vector> #include <vector>
#include "base/containers/flat_map.h"
#include "base/memory/raw_ptr.h" #include "base/memory/raw_ptr.h"
#include "base/memory/raw_ref.h" #include "base/memory/raw_ref.h"
#include "base/memory/weak_ptr.h" #include "base/memory/weak_ptr.h"
@ -274,11 +274,11 @@ class ProxyingURLLoaderFactory
// Mapping from our own internally generated request ID to an // Mapping from our own internally generated request ID to an
// InProgressRequest instance. // InProgressRequest instance.
std::map<uint64_t, std::unique_ptr<InProgressRequest>> requests_; base::flat_map<uint64_t, std::unique_ptr<InProgressRequest>> requests_;
// A mapping from the network stack's notion of request ID to our own // A mapping from the network stack's notion of request ID to our own
// internally generated request ID for the same request. // internally generated request ID for the same request.
std::map<int32_t, uint64_t> network_request_id_to_web_request_id_; base::flat_map<int32_t, uint64_t> network_request_id_to_web_request_id_;
std::vector<std::string> ignore_connections_limit_domains_; std::vector<std::string> ignore_connections_limit_domains_;
}; };

8
shell/browser/notifications/linux/libnotify_notification.cc
View file

@ -4,9 +4,9 @@
#include "shell/browser/notifications/linux/libnotify_notification.h" #include "shell/browser/notifications/linux/libnotify_notification.h"
#include <set>
#include <string> #include <string>
#include "base/containers/flat_set.h"
#include "base/files/file_enumerator.h" #include "base/files/file_enumerator.h"
#include "base/functional/bind.h" #include "base/functional/bind.h"
#include "base/logging.h" #include "base/logging.h"
@ -24,8 +24,8 @@ namespace {
LibNotifyLoader libnotify_loader_; LibNotifyLoader libnotify_loader_;
const std::set<std::string>& GetServerCapabilities() { const base::flat_set<std::string>& GetServerCapabilities() {
static std::set<std::string> caps; static base::flat_set<std::string> caps;
if (caps.empty()) { if (caps.empty()) {
auto* capabilities = libnotify_loader_.notify_get_server_caps(); auto* capabilities = libnotify_loader_.notify_get_server_caps();
for (auto* l = capabilities; l != nullptr; l = l->next) for (auto* l = capabilities; l != nullptr; l = l->next)
@ -36,7 +36,7 @@ const std::set<std::string>& GetServerCapabilities() {
} }
bool HasCapability(const std::string& capability) { bool HasCapability(const std::string& capability) {
return GetServerCapabilities().count(capability) != 0; return GetServerCapabilities().contains(capability);
} }
bool NotifierSupportsActions() { bool NotifierSupportsActions() {

8
shell/browser/ui/electron_menu_model.h
View file

@ -5,10 +5,10 @@
#ifndef ELECTRON_SHELL_BROWSER_UI_ELECTRON_MENU_MODEL_H_ #ifndef ELECTRON_SHELL_BROWSER_UI_ELECTRON_MENU_MODEL_H_
#define ELECTRON_SHELL_BROWSER_UI_ELECTRON_MENU_MODEL_H_ #define ELECTRON_SHELL_BROWSER_UI_ELECTRON_MENU_MODEL_H_
#include <map>
#include <string> #include <string>
#include <vector> #include <vector>
#include "base/containers/flat_map.h"
#include "base/files/file_path.h" #include "base/files/file_path.h"
#include "base/memory/raw_ptr.h" #include "base/memory/raw_ptr.h"
#include "base/memory/weak_ptr.h" #include "base/memory/weak_ptr.h"
@ -119,9 +119,9 @@ class ElectronMenuModel : public ui::SimpleMenuModel {
absl::optional<SharingItem> sharing_item_; absl::optional<SharingItem> sharing_item_;
#endif #endif
std::map<int, std::u16string> toolTips_; // command id -> tooltip base::flat_map<int, std::u16string> toolTips_; // command id -> tooltip
std::map<int, std::u16string> roles_; // command id -> role base::flat_map<int, std::u16string> roles_; // command id -> role
std::map<int, std::u16string> sublabels_; // command id -> sublabel base::flat_map<int, std::u16string> sublabels_; // command id -> sublabel
base::ObserverList<Observer> observers_; base::ObserverList<Observer> observers_;
base::WeakPtrFactory<ElectronMenuModel> weak_factory_{this}; base::WeakPtrFactory<ElectronMenuModel> weak_factory_{this};

4
shell/browser/ui/gtk/menu_util.cc
View file

@ -7,9 +7,9 @@
#include <gdk/gdk.h> #include <gdk/gdk.h>
#include <gtk/gtk.h> #include <gtk/gtk.h>
#include <map>
#include <string> #include <string>
#include "base/containers/flat_map.h"
#include "base/strings/utf_string_conversions.h" #include "base/strings/utf_string_conversions.h"
#include "chrome/app/chrome_command_ids.h" #include "chrome/app/chrome_command_ids.h"
#include "shell/browser/ui/gtk_util.h" #include "shell/browser/ui/gtk_util.h"
@ -150,7 +150,7 @@ void BuildSubmenuFromModel(ui::MenuModel* model,
MenuActivatedCallback item_activated_cb, MenuActivatedCallback item_activated_cb,
bool* block_activation, bool* block_activation,
std::vector<ScopedGSignal>* signals) { std::vector<ScopedGSignal>* signals) {
std::map<int, GtkWidget*> radio_groups; base::flat_map<int, GtkWidget*> radio_groups;
GtkWidget* menu_item = nullptr; GtkWidget* menu_item = nullptr;
for (size_t i = 0; i < model->GetItemCount(); ++i) { for (size_t i = 0; i < model->GetItemCount(); ++i) {
std::string label = ui::ConvertAcceleratorsFromWindowsStyle( std::string label = ui::ConvertAcceleratorsFromWindowsStyle(

7
shell/browser/ui/inspectable_web_contents.cc
View file

@ -203,11 +203,10 @@ class InspectableWebContents::NetworkResourceLoader
URLLoaderFactoryHolder url_loader_factory, URLLoaderFactoryHolder url_loader_factory,
DispatchCallback callback, DispatchCallback callback,
base::TimeDelta retry_delay = base::TimeDelta()) { base::TimeDelta retry_delay = base::TimeDelta()) {
auto resource_loader = bindings->loaders_.insert(
std::make_unique<InspectableWebContents::NetworkResourceLoader>( std::make_unique<InspectableWebContents::NetworkResourceLoader>(
stream_id, bindings, resource_request, traffic_annotation, stream_id, bindings, resource_request, traffic_annotation,
std::move(url_loader_factory), std::move(callback), retry_delay); std::move(url_loader_factory), std::move(callback), retry_delay));
bindings->loaders_.insert(std::move(resource_loader));
} }
NetworkResourceLoader( NetworkResourceLoader(
@ -308,7 +307,7 @@ class InspectableWebContents::NetworkResourceLoader
std::move(callback_).Run(&response); std::move(callback_).Run(&response);
} }
bindings_->loaders_.erase(bindings_->loaders_.find(this)); bindings_->loaders_.erase(this);
} }
void OnRetry(base::OnceClosure start_retry) override {} void OnRetry(base::OnceClosure start_retry) override {}

11
shell/browser/ui/inspectable_web_contents.h
View file

@ -6,11 +6,11 @@
#ifndef ELECTRON_SHELL_BROWSER_UI_INSPECTABLE_WEB_CONTENTS_H_ #ifndef ELECTRON_SHELL_BROWSER_UI_INSPECTABLE_WEB_CONTENTS_H_
#define ELECTRON_SHELL_BROWSER_UI_INSPECTABLE_WEB_CONTENTS_H_ #define ELECTRON_SHELL_BROWSER_UI_INSPECTABLE_WEB_CONTENTS_H_
#include <map>
#include <memory> #include <memory>
#include <set>
#include <string> #include <string>
#include "base/containers/flat_map.h"
#include "base/containers/flat_set.h"
#include "base/containers/span.h" #include "base/containers/span.h"
#include "base/containers/unique_ptr_adapters.h" #include "base/containers/unique_ptr_adapters.h"
#include "base/memory/raw_ptr.h" #include "base/memory/raw_ptr.h"
@ -241,11 +241,12 @@ class InspectableWebContents
embedder_message_dispatcher_; embedder_message_dispatcher_;
class NetworkResourceLoader; class NetworkResourceLoader;
std::set<std::unique_ptr<NetworkResourceLoader>, base::UniquePtrComparator> base::flat_set<std::unique_ptr<NetworkResourceLoader>,
base::UniquePtrComparator>
loaders_; loaders_;
using ExtensionsAPIs = std::map<std::string, std::string>; // origin -> script
ExtensionsAPIs extensions_api_; base::flat_map<std::string, std::string> extensions_api_;
// Contains the set of synced settings. // Contains the set of synced settings.
// The DevTools frontend *must* call `Register` for each setting prior to // The DevTools frontend *must* call `Register` for each setting prior to

7
shell/browser/ui/message_box_gtk.cc
View file

@ -4,9 +4,8 @@
#include "shell/browser/ui/message_box.h" #include "shell/browser/ui/message_box.h"
#include <map>
#include "base/containers/contains.h" #include "base/containers/contains.h"
#include "base/containers/flat_map.h"
#include "base/functional/bind.h" #include "base/functional/bind.h"
#include "base/functional/callback.h" #include "base/functional/callback.h"
#include "base/memory/raw_ptr.h" #include "base/memory/raw_ptr.h"
@ -43,8 +42,8 @@ MessageBoxSettings::~MessageBoxSettings() = default;
namespace { namespace {
// <ID, messageBox> map // <ID, messageBox> map
std::map<int, GtkWidget*>& GetDialogsMap() { base::flat_map<int, GtkWidget*>& GetDialogsMap() {
static base::NoDestructor<std::map<int, GtkWidget*>> dialogs; static base::NoDestructor<base::flat_map<int, GtkWidget*>> dialogs;
return *dialogs; return *dialogs;
} }

6
shell/browser/ui/message_box_mac.mm
View file

@ -4,7 +4,6 @@
#include "shell/browser/ui/message_box.h" #include "shell/browser/ui/message_box.h"
#include <map>
#include <string> #include <string>
#include <utility> #include <utility>
#include <vector> #include <vector>
@ -12,6 +11,7 @@
#import <Cocoa/Cocoa.h> #import <Cocoa/Cocoa.h>
#include "base/containers/contains.h" #include "base/containers/contains.h"
#include "base/containers/flat_map.h"
#include "base/functional/callback.h" #include "base/functional/callback.h"
#include "base/mac/mac_util.h" #include "base/mac/mac_util.h"
#include "base/no_destructor.h" #include "base/no_destructor.h"
@ -31,8 +31,8 @@ MessageBoxSettings::~MessageBoxSettings() = default;
namespace { namespace {
// <ID, messageBox> map // <ID, messageBox> map
std::map<int, NSAlert*>& GetDialogsMap() { base::flat_map<int, NSAlert*>& GetDialogsMap() {
static base::NoDestructor<std::map<int, NSAlert*>> dialogs; static base::NoDestructor<base::flat_map<int, NSAlert*>> dialogs;
return *dialogs; return *dialogs;
} }

10
shell/browser/ui/message_box_win.cc
View file

@ -8,10 +8,10 @@
#include <commctrl.h> #include <commctrl.h>
#include <map>
#include <vector> #include <vector>
#include "base/containers/contains.h" #include "base/containers/contains.h"
#include "base/containers/flat_map.h"
#include "base/no_destructor.h" #include "base/no_destructor.h"
#include "base/strings/string_util.h" #include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h" #include "base/strings/utf_string_conversions.h"
@ -41,8 +41,8 @@ struct DialogResult {
// Note that the HWND is stored in a unique_ptr, because the pointer of HWND // Note that the HWND is stored in a unique_ptr, because the pointer of HWND
// will be passed between threads and we need to ensure the memory of HWND is // will be passed between threads and we need to ensure the memory of HWND is
// not changed while dialogs map is modified. // not changed while dialogs map is modified.
std::map<int, std::unique_ptr<HWND>>& GetDialogsMap() { base::flat_map<int, std::unique_ptr<HWND>>& GetDialogsMap() {
static base::NoDestructor<std::map<int, std::unique_ptr<HWND>>> dialogs; static base::NoDestructor<base::flat_map<int, std::unique_ptr<HWND>>> dialogs;
return *dialogs; return *dialogs;
} }
@ -95,7 +95,7 @@ CommonButtonID GetCommonID(const std::wstring& button) {
// Determine whether the buttons are common buttons, if so map common ID // Determine whether the buttons are common buttons, if so map common ID
// to button ID. // to button ID.
void MapToCommonID(const std::vector<std::wstring>& buttons, void MapToCommonID(const std::vector<std::wstring>& buttons,
std::map<int, int>* id_map, base::flat_map<int, int>* id_map,
TASKDIALOG_COMMON_BUTTON_FLAGS* button_flags, TASKDIALOG_COMMON_BUTTON_FLAGS* button_flags,
std::vector<TASKDIALOG_BUTTON>* dialog_buttons) { std::vector<TASKDIALOG_BUTTON>* dialog_buttons) {
for (size_t i = 0; i < buttons.size(); ++i) { for (size_t i = 0; i < buttons.size(); ++i) {
@ -215,7 +215,7 @@ DialogResult ShowTaskDialogWstr(gfx::AcceleratedWidget parent,
// Iterate through the buttons, put common buttons in dwCommonButtons // Iterate through the buttons, put common buttons in dwCommonButtons
// and custom buttons in pButtons. // and custom buttons in pButtons.
std::map<int, int> id_map; base::flat_map<int, int> id_map;
std::vector<TASKDIALOG_BUTTON> dialog_buttons; std::vector<TASKDIALOG_BUTTON> dialog_buttons;
if (no_link) { if (no_link) {
for (size_t i = 0; i < buttons.size(); ++i) for (size_t i = 0; i < buttons.size(); ++i)

6
shell/browser/ui/views/electron_views_delegate.h
View file

@ -5,11 +5,11 @@
#ifndef ELECTRON_SHELL_BROWSER_UI_VIEWS_ELECTRON_VIEWS_DELEGATE_H_ #ifndef ELECTRON_SHELL_BROWSER_UI_VIEWS_ELECTRON_VIEWS_DELEGATE_H_
#define ELECTRON_SHELL_BROWSER_UI_VIEWS_ELECTRON_VIEWS_DELEGATE_H_ #define ELECTRON_SHELL_BROWSER_UI_VIEWS_ELECTRON_VIEWS_DELEGATE_H_
#include <map>
#include <memory> #include <memory>
#include <string> #include <string>
#include "base/compiler_specific.h" #include "base/compiler_specific.h"
#include "base/containers/flat_map.h"
#include "ui/views/views_delegate.h" #include "ui/views/views_delegate.h"
namespace electron { namespace electron {
@ -58,8 +58,6 @@ class ViewsDelegate : public views::ViewsDelegate {
private: private:
#if BUILDFLAG(IS_WIN) #if BUILDFLAG(IS_WIN)
using AppbarAutohideEdgeMap = std::map<HMONITOR, int>;
// Callback on main thread with the edges. |returned_edges| is the value that // Callback on main thread with the edges. |returned_edges| is the value that
// was returned from the call to GetAutohideEdges() that initiated the lookup. // was returned from the call to GetAutohideEdges() that initiated the lookup.
void OnGotAppbarAutohideEdges(base::OnceClosure callback, void OnGotAppbarAutohideEdges(base::OnceClosure callback,
@ -67,7 +65,7 @@ class ViewsDelegate : public views::ViewsDelegate {
int returned_edges, int returned_edges,
int edges); int edges);
AppbarAutohideEdgeMap appbar_autohide_edge_map_; base::flat_map<HMONITOR, int> appbar_autohide_edge_map_;
// If true we're in the process of notifying a callback from // If true we're in the process of notifying a callback from
// GetAutohideEdges().start a new query. // GetAutohideEdges().start a new query.
bool in_autohide_edges_callback_ = false; bool in_autohide_edges_callback_ = false;

2
shell/browser/ui/views/electron_views_delegate_win.cc
View file

@ -119,7 +119,7 @@ int ViewsDelegate::GetAppbarAutohideEdges(HMONITOR monitor,
// in us thinking there is no auto-hide edges. By returning at least one edge // in us thinking there is no auto-hide edges. By returning at least one edge
// we don't initially go fullscreen until we figure out the real auto-hide // we don't initially go fullscreen until we figure out the real auto-hide
// edges. // edges.
if (!appbar_autohide_edge_map_.count(monitor)) if (!appbar_autohide_edge_map_.contains(monitor))
appbar_autohide_edge_map_[monitor] = EDGE_BOTTOM; appbar_autohide_edge_map_[monitor] = EDGE_BOTTOM;
// We use the SHAppBarMessage API to get the taskbar autohide state. This API // We use the SHAppBarMessage API to get the taskbar autohide state. This API

5
shell/browser/web_view_manager.h
View file

@ -5,8 +5,7 @@
#ifndef ELECTRON_SHELL_BROWSER_WEB_VIEW_MANAGER_H_ #ifndef ELECTRON_SHELL_BROWSER_WEB_VIEW_MANAGER_H_
#define ELECTRON_SHELL_BROWSER_WEB_VIEW_MANAGER_H_ #define ELECTRON_SHELL_BROWSER_WEB_VIEW_MANAGER_H_
#include <map> #include "base/containers/flat_map.h"
#include "base/memory/raw_ptr.h" #include "base/memory/raw_ptr.h"
#include "content/public/browser/browser_plugin_guest_manager.h" #include "content/public/browser/browser_plugin_guest_manager.h"
@ -38,7 +37,7 @@ class WebViewManager : public content::BrowserPluginGuestManager {
raw_ptr<content::WebContents> embedder; raw_ptr<content::WebContents> embedder;
}; };
// guest_instance_id => (web_contents, embedder) // guest_instance_id => (web_contents, embedder)
std::map<int, WebContentsWithEmbedder> web_contents_embedder_map_; base::flat_map<int, WebContentsWithEmbedder> web_contents_embedder_map_;
}; };
} // namespace electron } // namespace electron

6
shell/common/api/electron_api_native_image.h
View file

@ -5,10 +5,10 @@
#ifndef ELECTRON_SHELL_COMMON_API_ELECTRON_API_NATIVE_IMAGE_H_ #ifndef ELECTRON_SHELL_COMMON_API_ELECTRON_API_NATIVE_IMAGE_H_
#define ELECTRON_SHELL_COMMON_API_ELECTRON_API_NATIVE_IMAGE_H_ #define ELECTRON_SHELL_COMMON_API_ELECTRON_API_NATIVE_IMAGE_H_
#include <map>
#include <string> #include <string>
#include <vector> #include <vector>
#include "base/containers/flat_map.h"
#include "base/memory/raw_ptr.h" #include "base/memory/raw_ptr.h"
#include "base/values.h" #include "base/values.h"
#include "gin/handle.h" #include "gin/handle.h"
@ -130,7 +130,9 @@ class NativeImage : public gin::Wrappable<NativeImage> {
#if BUILDFLAG(IS_WIN) #if BUILDFLAG(IS_WIN)
base::FilePath hicon_path_; base::FilePath hicon_path_;
std::map<int, base::win::ScopedHICON> hicons_;
// size -> hicon
base::flat_map<int, base::win::ScopedHICON> hicons_;
#endif #endif
gfx::Image image_; gfx::Image image_;

6
shell/renderer/electron_renderer_client.h
View file

@ -6,8 +6,8 @@
#define ELECTRON_SHELL_RENDERER_ELECTRON_RENDERER_CLIENT_H_ #define ELECTRON_SHELL_RENDERER_ELECTRON_RENDERER_CLIENT_H_
#include <memory> #include <memory>
#include <set>
#include "base/containers/flat_set.h"
#include "shell/renderer/renderer_client_base.h" #include "shell/renderer/renderer_client_base.h"
namespace node { namespace node {
@ -57,12 +57,12 @@ class ElectronRendererClient : public RendererClientBase {
// The node::Environment::GetCurrent API does not return nullptr when it // The node::Environment::GetCurrent API does not return nullptr when it
// is called for a context without node::Environment, so we have to keep // is called for a context without node::Environment, so we have to keep
// a book of the environments created. // a book of the environments created.
std::set<std::shared_ptr<node::Environment>> environments_; base::flat_set<std::shared_ptr<node::Environment>> environments_;
// Getting main script context from web frame would lazily initializes // Getting main script context from web frame would lazily initializes
// its script context. Doing so in a web page without scripts would trigger // its script context. Doing so in a web page without scripts would trigger
// assertion, so we have to keep a book of injected web frames. // assertion, so we have to keep a book of injected web frames.
std::set<content::RenderFrame*> injected_frames_; base::flat_set<content::RenderFrame*> injected_frames_;
}; };
} // namespace electron } // namespace electron

2
shell/renderer/web_worker_observer.cc
View file

@ -98,7 +98,7 @@ void WebWorkerObserver::ContextWillDestroy(v8::Local<v8::Context> context) {
DCHECK_EQ(microtask_queue->GetMicrotasksScopeDepth(), 0); DCHECK_EQ(microtask_queue->GetMicrotasksScopeDepth(), 0);
microtask_queue->set_microtasks_policy(v8::MicrotasksPolicy::kExplicit); microtask_queue->set_microtasks_policy(v8::MicrotasksPolicy::kExplicit);
std::erase_if(environments_, base::EraseIf(environments_,
[env](auto const& item) { return item.get() == env; }); [env](auto const& item) { return item.get() == env; });
microtask_queue->set_microtasks_policy(old_policy); microtask_queue->set_microtasks_policy(old_policy);

4
shell/renderer/web_worker_observer.h
View file

@ -6,8 +6,8 @@
#define ELECTRON_SHELL_RENDERER_WEB_WORKER_OBSERVER_H_ #define ELECTRON_SHELL_RENDERER_WEB_WORKER_OBSERVER_H_
#include <memory> #include <memory>
#include <set>
#include "base/containers/flat_set.h"
#include "v8/include/v8.h" #include "v8/include/v8.h"
namespace node { namespace node {
@ -42,7 +42,7 @@ class WebWorkerObserver {
private: private:
std::unique_ptr<NodeBindings> node_bindings_; std::unique_ptr<NodeBindings> node_bindings_;
std::unique_ptr<ElectronBindings> electron_bindings_; std::unique_ptr<ElectronBindings> electron_bindings_;
std::set<std::shared_ptr<node::Environment>> environments_; base::flat_set<std::shared_ptr<node::Environment>> environments_;
}; };
} // namespace electron } // namespace electron