--- base/allocator/partition_allocator/src/partition_alloc/partition_alloc_base/no_destructor.h.orig	2024-06-13 07:40:39 UTC

+++ base/allocator/partition_allocator/src/partition_alloc/partition_alloc_base/no_destructor.h

@@ -122,9 +122,7 @@ class NoDestructor {

       new (storage_) T(std::forward<Args>(args)...);

     }

-    const T* get() const {

-      return const_cast<PlacementStorage*>(this)->storage();

-    }

+    const T* get() const { return const_cast<PlacementStorage*>(this)->get(); }

     T* get() { return reinterpret_cast<T*>(storage_); }

    private:

--- base/containers/id_map.h.orig	2024-06-13 07:40:39 UTC

+++ base/containers/id_map.h

@@ -178,8 +178,8 @@ class IDMap final {

     }

     const Iterator& operator=(const Iterator& iter) {

-      map_ = iter.map;

-      iter_ = iter.iter;

+      map_ = iter.map_;

+      iter_ = iter.iter_;

       Init();

       return *this;

     }

--- electron/shell/common/keyboard_util.cc.orig	2024-09-10 16:10:30 UTC

+++ electron/shell/common/keyboard_util.cc

@@ -16,7 +16,7 @@ using CodeAndShiftedChar = std::pair<ui::KeyboardCode,

 using CodeAndShiftedChar = std::pair<ui::KeyboardCode, std::optional<char16_t>>;

-constexpr CodeAndShiftedChar KeyboardCodeFromKeyIdentifier(

+CodeAndShiftedChar KeyboardCodeFromKeyIdentifier(

     const std::string_view str) {

 #if BUILDFLAG(IS_MAC)

   constexpr auto CommandOrControl = ui::VKEY_COMMAND;

--- net/third_party/quiche/src/quiche/quic/core/quic_interval_deque.h.orig	2024-06-13 07:42:15 UTC

+++ net/third_party/quiche/src/quiche/quic/core/quic_interval_deque.h

@@ -198,12 +198,12 @@ class QUICHE_NO_EXPORT QuicIntervalDeque {

     Iterator operator+(difference_type amount) const {

       Iterator copy = *this;

       copy.index_ += amount;

-      QUICHE_DCHECK(copy.index_ < copy.deque_->size());

+      QUICHE_DCHECK(copy.index_ < copy.deque_->Size());

       return copy;

     }

     Iterator& operator+=(difference_type amount) {

       index_ += amount;

-      QUICHE_DCHECK(index_ < deque_->size());

+      QUICHE_DCHECK(index_ < deque_->Size());

       return *this;

     }

     difference_type operator-(const Iterator& rhs) const {

--- third_party/blink/renderer/platform/wtf/hash_table.h.orig	2024-06-13 07:40:54 UTC

+++ third_party/blink/renderer/platform/wtf/hash_table.h

@@ -1632,7 +1632,7 @@ HashTable<Key, Value, Extractor, Traits, KeyTraits, Al

     }

   }

   table_ = temporary_table;

-  Allocator::template BackingWriteBarrier(&table_);

+  Allocator::BackingWriteBarrier(&table_);

   HashTableBucketInitializer<Traits, Allocator, Value>::InitializeTable(

       original_table, new_table_size);

@@ -1686,7 +1686,7 @@ Value* HashTable<Key, Value, Extractor, Traits, KeyTra

   // This swaps the newly allocated buffer with the current one. The store to

   // the current table has to be atomic to prevent races with concurrent marker.

   AsAtomicPtr(&table_)->store(new_hash_table.table_, std::memory_order_relaxed);

-  Allocator::template BackingWriteBarrier(&table_);

+  Allocator::BackingWriteBarrier(&table_);

   table_size_ = new_table_size;

   new_hash_table.table_ = old_table;

@@ -1838,8 +1838,8 @@ void HashTable<Key, Value, Extractor, Traits, KeyTrait

   // on the mutator thread, which is also the only one that writes to them, so

   // there is *no* risk of data races when reading.

   AtomicWriteSwap(table_, other.table_);

-  Allocator::template BackingWriteBarrier(&table_);

-  Allocator::template BackingWriteBarrier(&other.table_);

+  Allocator::BackingWriteBarrier(&table_);

+  Allocator::BackingWriteBarrier(&other.table_);

   if (IsWeak<ValueType>::value) {

     // Weak processing is omitted when no backing store is present. In case such

     // an empty table is later on used it needs to be strongified.

--- third_party/perfetto/include/perfetto/tracing/internal/track_event_data_source.h.orig	2024-06-13 07:45:23 UTC

+++ third_party/perfetto/include/perfetto/tracing/internal/track_event_data_source.h

@@ -328,13 +328,13 @@ class TrackEventDataSource

   }

   static void Flush() {

-    Base::template Trace([](typename Base::TraceContext ctx) { ctx.Flush(); });

+    Base::Trace([](typename Base::TraceContext ctx) { ctx.Flush(); });

   }

   // Determine if *any* tracing category is enabled.

   static bool IsEnabled() {

     bool enabled = false;

-    Base::template CallIfEnabled(

+    Base::CallIfEnabled(

         [&](uint32_t /*instances*/) { enabled = true; });

     return enabled;

   }

@@ -349,7 +349,7 @@ class TrackEventDataSource

   static bool IsDynamicCategoryEnabled(

       const DynamicCategory& dynamic_category) {

     bool enabled = false;

-    Base::template Trace([&](typename Base::TraceContext ctx) {

+    Base::Trace([&](typename Base::TraceContext ctx) {

       enabled = enabled || IsDynamicCategoryEnabled(&ctx, dynamic_category);

     });

     return enabled;

@@ -496,7 +496,7 @@ class TrackEventDataSource

                                  const protos::gen::TrackDescriptor& desc) {

     PERFETTO_DCHECK(track.uuid == desc.uuid());

     TrackRegistry::Get()->UpdateTrack(track, desc.SerializeAsString());

-    Base::template Trace([&](typename Base::TraceContext ctx) {

+    Base::Trace([&](typename Base::TraceContext ctx) {

       TrackEventInternal::WriteTrackDescriptor(

           track, ctx.tls_inst_->trace_writer.get(), ctx.GetIncrementalState(),

           *ctx.GetCustomTlsState(), TrackEventInternal::GetTraceTime());

@@ -1047,7 +1047,7 @@ class TrackEventDataSource

                                  Lambda lambda) PERFETTO_ALWAYS_INLINE {

     using CatTraits = CategoryTraits<CategoryType>;

     if (CatTraits::kIsDynamic) {

-      Base::template TraceWithInstances(instances, std::move(lambda));

+      Base::TraceWithInstances(instances, std::move(lambda));

     } else {

       Base::template TraceWithInstances<CategoryTracePointTraits>(

           instances, std::move(lambda), {CatTraits::GetStaticIndex(category)});

@@ -1061,7 +1061,7 @@ class TrackEventDataSource

       const TrackType& track,

       std::function<void(protos::pbzero::TrackDescriptor*)> callback) {

     TrackRegistry::Get()->UpdateTrack(track, std::move(callback));

-    Base::template Trace([&](typename Base::TraceContext ctx) {

+    Base::Trace([&](typename Base::TraceContext ctx) {

       TrackEventInternal::WriteTrackDescriptor(

           track, ctx.tls_inst_->trace_writer.get(), ctx.GetIncrementalState(),

           *ctx.GetCustomTlsState(), TrackEventInternal::GetTraceTime());