DEBUG

DEBUG

Author: jsoningram

special-pages/pages/new-tab/app/activity/NormalizeDataProvider.js

@@ -224,12 +224,25 @@ export function SignalStateProvider({ children }) {
         if (!service) return console.warn('could not access service');
         const src = /** @type {import("./batched-activity.service.js").BatchedActivityService} */ (service);
         const unsub = src.onData((evt) => {
+            console.log('[NormalizeDataProvider] Received activity data update:', {
+                source: evt.source,
+                activityCount: evt.data.activity.length,
+                totalTrackers: evt.data.totalTrackers,
+                urls: evt.data.urls.slice(0, 5), // Log first 5 URLs
+            });
             batch(() => {
+                const oldActivity = activity.value;
                 activity.value = normalizeData(activity.value, {
                     activity: evt.data.activity,
                     urls: evt.data.urls,
                     totalTrackers: evt.data.totalTrackers,
                 });
+                console.log('[NormalizeDataProvider] Activity data normalized:', {
+                    oldTotalTrackers: oldActivity.totalTrackers,
+                    newTotalTrackers: activity.value.totalTrackers,
+                    oldItemCount: Object.keys(oldActivity.items).length,
+                    newItemCount: Object.keys(activity.value.items).length,
+                });
                 const visible = keys.value;
                 const all = activity.value.urls;
 

special-pages/pages/new-tab/app/activity/batched-activity.service.js

@@ -55,6 +55,11 @@ export class BatchedActivityService {
             },
             subscribe: (cb) => {
                 const sub1 = ntp.messaging.subscribe('activity_onDataUpdate', (params) => {
+                    console.log('[BatchedActivity] activity_onDataUpdate received:', {
+                        activityCount: params.activity.length,
+                        totalTrackers: params.activity.reduce((acc, item) => acc + item.trackingStatus.totalCount, 0),
+                        urls: params.activity.map((x) => x.url),
+                    });
                     cb({
                         activity: params.activity,
                         urls: params.activity.map((x) => x.url),
@@ -63,6 +68,12 @@ export class BatchedActivityService {
                 });
                 const sub2 = ntp.messaging.subscribe('activity_onDataPatch', (params) => {
                     const totalTrackers = params.totalTrackersBlocked;
+                    console.log('[BatchedActivity] activity_onDataPatch received:', {
+                        hasPatch: 'patch' in params && params.patch !== null,
+                        totalTrackers,
+                        urls: params.urls,
+                        patchUrl: params.patch?.url,
+                    });
                     if ('patch' in params && params.patch !== null) {
                         cb({ activity: [/** @type {DomainActivity} */ (params.patch)], urls: params.urls, totalTrackers });
                     } else {
@@ -91,6 +102,7 @@ export class BatchedActivityService {
         /** @type {EventTarget|null} */
         this.burns = new EventTarget();
         this.burnUnsub = this.ntp.messaging.subscribe('activity_onBurnComplete', () => {
+            console.log('[BatchedActivity] activity_onBurnComplete received from native');
             this.burns?.dispatchEvent(new CustomEvent('activity_onBurnComplete'));
         });
     }
@@ -216,10 +228,12 @@ export class BatchedActivityService {
     }
 
     enableBroadcast() {
+        console.log('[BatchedActivity] enableBroadcast called');
         this.dataService.enableBroadcast();
         this.dataService.flush();
     }
     disableBroadcast() {
+        console.log('[BatchedActivity] disableBroadcast called');
         this.dataService.disableBroadcast();
     }
 }

special-pages/pages/new-tab/app/burning/BurnProvider.js

@@ -44,10 +44,15 @@ export function BurnProvider({ children, service, showBurnAnimation = true }) {
         if (burning.value.length > 0 || exiting.value.length > 0) return;
 
         const value = button.value;
+        console.log('[BurnProvider] Starting burn for:', value);
         const response = await service?.confirmBurn(value);
-        if (response && response.action === 'none') return;
+        if (response && response.action === 'none') {
+            console.log('[BurnProvider] Burn cancelled by user');
+            return;
+        }
 
         // stop the service broadcasting any updates for a moment
+        console.log('[BurnProvider] Disabling broadcast and marking as burning');
         service.disableBroadcast();
 
         // mark this item as burning - this will prevent further events until we're done
@@ -65,9 +70,11 @@ export function BurnProvider({ children, service, showBurnAnimation = true }) {
         // but don't wait any longer than 3 seconds
         const withTimer = any(required, timer(3000));
 
+        console.log('[BurnProvider] Waiting for FE and native signals...');
         // exec the chain
         await toPromise(withTimer);
 
+        console.log('[BurnProvider] Burn complete, clearing state and re-enabling broadcast');
         // when we get here, clear out all state
         batch(() => {
             exiting.value = [];

special-pages/pages/new-tab/app/protections/components/ProtectionsProvider.js

@@ -121,31 +121,47 @@ export function useBlockedCount(initial) {
     // BatchedActivityService already subscribes to activity_onBurnComplete and dispatches this event
     useEffect(() => {
         if (!activityService?.burns) return;
-        
+
         const handleBurnComplete = () => {
             // Mark that we should skip animation if next update goes to 0
+            console.log('[ProtectionsProvider] Burn complete event received, setting burnCompleteTimeRef');
             burnCompleteTimeRef.current = Date.now();
+
+            // WORKAROUND: Manually trigger protections data refresh since native doesn't send protections_onDataUpdate
+            console.log('[ProtectionsProvider] WORKAROUND: Manually triggering protections data refresh');
+            service?.dataService?.triggerFetch?.();
         };
-        
+
         const burns = activityService.burns;
         burns.addEventListener('activity_onBurnComplete', handleBurnComplete);
         return () => {
             // Use the captured burns reference to ensure we remove from the correct EventTarget
             // even if activityService is destroyed/unmounted
             burns?.removeEventListener('activity_onBurnComplete', handleBurnComplete);
         };
-    }, [activityService, burnCompleteTimeRef]);
+    }, [activityService, burnCompleteTimeRef, service]);
 
     // @todo jingram possibly refactor to include full object
     useSignalEffect(() => {
         return service?.onData((evt) => {
             const newValue = evt.data.totalCount;
             const previousValue = signal.value;
-            
+            console.log('[ProtectionsProvider.useBlockedCount] Protections data update received:', {
+                source: evt.source,
+                previousValue,
+                newValue,
+                totalCookiePopUpsBlocked: evt.data.totalCookiePopUpsBlocked,
+                burnCompleteTimeSet: burnCompleteTimeRef.current !== null,
+            });
+
             // If transitioning to 0 and we just had a burn complete (within 1 second),
             // this is likely a "burn all" operation - skip animation and go directly to empty state
             if (newValue === 0 && previousValue > 0 && burnCompleteTimeRef.current !== null) {
                 const timeSinceBurn = Date.now() - burnCompleteTimeRef.current;
+                console.log('[ProtectionsProvider.useBlockedCount] Checking burn all condition:', {
+                    timeSinceBurn,
+                    willSkipAnimation: timeSinceBurn < 1000,
+                });
                 if (timeSinceBurn < 1000) {
                     // Set skipAnimation flag before updating the signal value
                     // This ensures useAnimatedCount immediately sets to 0 without animating
@@ -159,7 +175,7 @@ export function useBlockedCount(initial) {
                     return;
                 }
             }
-            
+
             // Normal update (including single domain burns) - allow animation for both counts
             // This ensures both tracker count and cookie pop-ups count animate when burning a single domain
             skipAnimationSignal.value = false;
@@ -180,7 +196,14 @@ export function useCookiePopUpsBlockedCount(initial) {
 
     useSignalEffect(() => {
         return service?.onData((evt) => {
-            signal.value = evt.data.totalCookiePopUpsBlocked;
+            const previousValue = signal.value;
+            const newValue = evt.data.totalCookiePopUpsBlocked;
+            console.log('[ProtectionsProvider.useCookiePopUpsBlockedCount] Cookie pop-ups count update:', {
+                source: evt.source,
+                previousValue,
+                newValue,
+            });
+            signal.value = newValue;
         });
     });
 

special-pages/pages/new-tab/app/service.js

@@ -109,14 +109,17 @@ export class Service {
     }
 
     disableBroadcast() {
+        console.log('[Service] disableBroadcast called');
         this._broadcast = false;
     }
 
     enableBroadcast() {
+        console.log('[Service] enableBroadcast called');
         this._broadcast = true;
     }
 
     flush() {
+        console.log('[Service] flush called, has data:', this.data !== null);
         if (this.data) this._accept(this.data, 'manual');
     }
 
@@ -143,6 +146,12 @@ export class Service {
      * @private
      */
     _accept(data, source) {
+        console.log('[Service] _accept called:', {
+            source,
+            broadcast: this._broadcast,
+            hasData: data !== null,
+        });
+
         if (this.accept && source !== 'initial') {
             this.data = /** @type {NonNullable<Data>} */ (this.accept(/** @type {NonNullable<Data>} */ (this.data), data, source));
         } else {
@@ -155,8 +164,12 @@ export class Service {
         // always cancel any existing debounced timers
         this.clearDebounceTimer();
 
-        if (!this._broadcast) return console.warn('not broadcasting');
+        if (!this._broadcast) {
+            console.warn('[Service] NOT broadcasting - broadcast is disabled. Source:', source);
+            return;
+        }
 
+        console.log('[Service] Broadcasting data event. Source:', source);
         // always broadcast the change on the event target
         const dataEvent = new CustomEvent('data', {
             detail: {