Backed out changeset 5f53c5571125 (bug 1523878) for autobinscope.py bustages.
authorBrindusan Cristian <cbrindusan@mozilla.com>
Fri, 01 Feb 2019 09:28:06 +0200
changeset 456371 a5f0e7af6f5c9b45e6360ae86005ee75b2a1bb63
parent 456370 e565291ee5f6c863a5e247c078f0358142fb0062
child 456372 d58901c5036ffa06da6144f22a31479116ee0835
push idunknown
push userunknown
push dateunknown
bugs1523878
milestone67.0a1
backs out5f53c5571125b1c05187ceeaef7d21c30608e5b3
Backed out changeset 5f53c5571125 (bug 1523878) for autobinscope.py bustages.
dom/base/ContentBlockingLog.h
--- a/dom/base/ContentBlockingLog.h
+++ b/dom/base/ContentBlockingLog.h
@@ -21,206 +21,194 @@ namespace dom {
 
 class ContentBlockingLog final {
   struct LogEntry {
     uint32_t mType;
     uint32_t mRepeatCount;
     bool mBlocked;
   };
 
-  struct OriginDataEntry {
-    OriginDataEntry() : mHasTrackingContentLoaded(false) {}
-
-    bool mHasTrackingContentLoaded;
-    Maybe<bool> mHasCookiesLoaded;
-    nsTArray<LogEntry> mLogs;
-  };
-
-  struct OriginEntry {
-    OriginEntry() { mData = MakeUnique<OriginDataEntry>(); }
-
-    nsCString mOrigin;
-    UniquePtr<OriginDataEntry> mData;
-  };
-
-  typedef nsTArray<OriginEntry> OriginDataTable;
+  // Each element is a tuple of (type, blocked, repeatCount). The type values
+  // come from the blocking types defined in nsIWebProgressListener.
+  typedef nsTArray<LogEntry> OriginLog;
+  typedef Tuple<bool, Maybe<bool>, OriginLog> OriginData;
+  typedef nsTArray<Tuple<nsCString, UniquePtr<OriginData>>> OriginDataTable;
 
   struct StringWriteFunc : public JSONWriteFunc {
     nsACString&
         mBuffer;  // The lifetime of the struct must be bound to the buffer
     explicit StringWriteFunc(nsACString& aBuffer) : mBuffer(aBuffer) {}
 
     void Write(const char* aStr) override { mBuffer.Append(aStr); }
   };
 
   struct Comparator {
    public:
     bool Equals(const OriginDataTable::elem_type& aLeft,
                 const OriginDataTable::elem_type& aRight) const {
-      return aLeft.mOrigin.Equals(aRight.mOrigin);
+      return Get<0>(aLeft).Equals(Get<0>(aRight));
     }
 
     bool Equals(const OriginDataTable::elem_type& aLeft,
                 const nsACString& aRight) const {
-      return aLeft.mOrigin.Equals(aRight);
+      return Get<0>(aLeft).Equals(aRight);
     }
   };
 
  public:
   ContentBlockingLog() = default;
   ~ContentBlockingLog() = default;
 
   void RecordLog(const nsACString& aOrigin, uint32_t aType, bool aBlocked) {
     if (aOrigin.IsVoid()) {
       return;
     }
     auto index = mLog.IndexOf(aOrigin, 0, Comparator());
     if (index != OriginDataTable::NoIndex) {
-      OriginEntry& entry = mLog[index];
-      if (!entry.mData) {
-        return;
-      }
-
+      auto& data = Get<1>(mLog[index]);
       if (aType == nsIWebProgressListener::STATE_LOADED_TRACKING_CONTENT) {
-        entry.mData->mHasTrackingContentLoaded = aBlocked;
+        Get<0>(*data) = aBlocked;
         return;
       }
       if (aType == nsIWebProgressListener::STATE_COOKIES_LOADED) {
-        if (entry.mData->mHasCookiesLoaded.isSome()) {
-          entry.mData->mHasCookiesLoaded.ref() = aBlocked;
+        if (Get<1>(*data).isSome()) {
+          Get<1>(*data).ref() = aBlocked;
         } else {
-          entry.mData->mHasCookiesLoaded.emplace(aBlocked);
+          Get<1>(*data).emplace(aBlocked);
         }
         return;
       }
-      if (!entry.mData->mLogs.IsEmpty()) {
-        auto& last = entry.mData->mLogs.LastElement();
+      auto& log = Get<2>(*data);
+      if (!log.IsEmpty()) {
+        auto& last = log.LastElement();
         if (last.mType == aType && last.mBlocked == aBlocked) {
           ++last.mRepeatCount;
           // Don't record recorded events.  This helps compress our log.
           return;
         }
       }
-      if (entry.mData->mLogs.Length() ==
+      if (log.Length() ==
           std::max(1u,
                    StaticPrefs::browser_contentblocking_originlog_length())) {
         // Cap the size at the maximum length adjustable by the pref
-        entry.mData->mLogs.RemoveElementAt(0);
+        log.RemoveElementAt(0);
       }
-      entry.mData->mLogs.AppendElement(LogEntry{aType, 1u, aBlocked});
-      return;
-    }
-
-    // The entry has not been found.
-
-    OriginEntry* entry = mLog.AppendElement();
-    if (NS_WARN_IF(!entry || !entry->mData)) {
-      return;
-    }
-
-    entry->mOrigin = aOrigin;
-
-    if (aType == nsIWebProgressListener::STATE_LOADED_TRACKING_CONTENT) {
-      entry->mData->mHasTrackingContentLoaded = aBlocked;
-    } else if (aType == nsIWebProgressListener::STATE_COOKIES_LOADED) {
-      MOZ_ASSERT(entry->mData->mHasCookiesLoaded.isNothing());
-      entry->mData->mHasCookiesLoaded.emplace(aBlocked);
+      log.AppendElement(LogEntry{aType, 1u, aBlocked});
     } else {
-      entry->mData->mLogs.AppendElement(LogEntry{aType, 1u, aBlocked});
+      auto data = MakeUnique<OriginData>(false, Maybe<bool>(), OriginLog());
+      if (aType == nsIWebProgressListener::STATE_LOADED_TRACKING_CONTENT) {
+        Get<0>(*data) = aBlocked;
+      } else if (aType == nsIWebProgressListener::STATE_COOKIES_LOADED) {
+        if (Get<1>(*data).isSome()) {
+          Get<1>(*data).ref() = aBlocked;
+        } else {
+          Get<1>(*data).emplace(aBlocked);
+        }
+      } else {
+        Get<2>(*data).AppendElement(LogEntry{aType, 1u, aBlocked});
+      }
+      nsAutoCString origin(aOrigin);
+      mLog.AppendElement(Tuple<nsCString, UniquePtr<OriginData>>(
+          std::move(origin), std::move(data)));
     }
   }
 
   nsAutoCString Stringify() {
     nsAutoCString buffer;
 
     JSONWriter w(MakeUnique<StringWriteFunc>(buffer));
     w.Start();
 
-    for (const OriginEntry& entry : mLog) {
-      if (!entry.mData) {
+    const auto end = mLog.end();
+    for (auto iter = mLog.begin(); iter != end; ++iter) {
+      if (!Get<1>(*iter)) {
+        w.StartArrayProperty(Get<0>(*iter).get(), w.SingleLineStyle);
+        w.EndArray();
         continue;
       }
 
-      w.StartArrayProperty(entry.mOrigin.get(), w.SingleLineStyle);
-
-      if (entry.mData->mHasTrackingContentLoaded) {
+      w.StartArrayProperty(Get<0>(*iter).get(), w.SingleLineStyle);
+      auto& data = Get<1>(*iter);
+      if (Get<0>(*data)) {
         w.StartArrayElement(w.SingleLineStyle);
         {
           w.IntElement(nsIWebProgressListener::STATE_LOADED_TRACKING_CONTENT);
           w.BoolElement(true);  // blocked
           w.IntElement(1);      // repeat count
         }
         w.EndArray();
       }
-      if (entry.mData->mHasCookiesLoaded.isSome()) {
+      if (Get<1>(*data).isSome()) {
         w.StartArrayElement(w.SingleLineStyle);
         {
           w.IntElement(nsIWebProgressListener::STATE_COOKIES_LOADED);
-          w.BoolElement(entry.mData->mHasCookiesLoaded.value());  // blocked
-          w.IntElement(1);  // repeat count
+          w.BoolElement(Get<1>(*data).value());  // blocked
+          w.IntElement(1);                       // repeat count
         }
         w.EndArray();
       }
-      for (const LogEntry& item : entry.mData->mLogs) {
+      for (auto& item : Get<2>(*data)) {
         w.StartArrayElement(w.SingleLineStyle);
         {
           w.IntElement(item.mType);
           w.BoolElement(item.mBlocked);
           w.IntElement(item.mRepeatCount);
         }
         w.EndArray();
       }
       w.EndArray();
     }
 
     w.End();
 
     return buffer;
   }
 
-  bool HasBlockedAnyOfType(uint32_t aType) const {
+  bool HasBlockedAnyOfType(uint32_t aType) {
     // Note: nothing inside this loop should return false, the goal for the
     // loop is to scan the log to see if we find a matching entry, and if so
     // we would return true, otherwise in the end of the function outside of
     // the loop we take the common `return false;` statement.
-    for (const OriginEntry& entry : mLog) {
-      if (!entry.mData) {
+    const auto end = mLog.end();
+    for (auto iter = mLog.begin(); iter != end; ++iter) {
+      if (!Get<1>(*iter)) {
         continue;
       }
 
       if (aType == nsIWebProgressListener::STATE_LOADED_TRACKING_CONTENT) {
-        if (entry.mData->mHasTrackingContentLoaded) {
+        if (Get<0>(*Get<1>(*iter))) {
           return true;
         }
       } else if (aType == nsIWebProgressListener::STATE_COOKIES_LOADED) {
-        if (entry.mData->mHasCookiesLoaded.isSome() &&
-            entry.mData->mHasCookiesLoaded.value()) {
+        if (Get<1>(*Get<1>(*iter)).isSome() && Get<1>(*Get<1>(*iter)).value()) {
           return true;
         }
       } else {
-        for (const auto& item : entry.mData->mLogs) {
+        for (auto& item : Get<2>(*Get<1>(*iter))) {
           if (((item.mType & aType) != 0) && item.mBlocked) {
             return true;
           }
         }
       }
     }
     return false;
   }
 
   void AddSizeOfExcludingThis(nsWindowSizes& aSizes) const {
     aSizes.mDOMOtherSize +=
         mLog.ShallowSizeOfExcludingThis(aSizes.mState.mMallocSizeOf);
 
     // Now add the sizes of each origin log queue.
-    for (const OriginEntry& entry : mLog) {
-      if (entry.mData) {
-        aSizes.mDOMOtherSize += aSizes.mState.mMallocSizeOf(entry.mData.get()) +
-                                entry.mData->mLogs.ShallowSizeOfExcludingThis(
-                                    aSizes.mState.mMallocSizeOf);
+    const auto end = mLog.end();
+    for (auto iter = mLog.begin(); iter != end; ++iter) {
+      if (!Get<1>(*iter)) {
+        aSizes.mDOMOtherSize +=
+            aSizes.mState.mMallocSizeOf(Get<1>(*iter).get()) +
+            Get<2>(*Get<1>(*iter))
+                .ShallowSizeOfExcludingThis(aSizes.mState.mMallocSizeOf);
       }
     }
   }
 
  private:
   OriginDataTable mLog;
 };