The Tor Browser: mobile/android/tests/background/junit3/src/testhelpers/WBORepository.java@6474c204b198 (annotated)

mobile/android/tests/background/junit3/src/testhelpers/WBORepository.java@6474c204b198 (annotated)

mobile/android/tests/background/junit3/src/testhelpers/WBORepository.java

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 package org.mozilla.gecko.background.testhelpers;
 import java.util.Map.Entry;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import org.mozilla.gecko.background.common.log.Logger;
 import org.mozilla.gecko.sync.repositories.InactiveSessionException;
 import org.mozilla.gecko.sync.repositories.InvalidSessionTransitionException;
 import org.mozilla.gecko.sync.repositories.NoStoreDelegateException;
 import org.mozilla.gecko.sync.repositories.RecordFilter;
 import org.mozilla.gecko.sync.repositories.Repository;
 import org.mozilla.gecko.sync.repositories.StoreTrackingRepositorySession;
 import org.mozilla.gecko.sync.repositories.delegates.RepositorySessionBeginDelegate;
 import org.mozilla.gecko.sync.repositories.delegates.RepositorySessionCreationDelegate;
 import org.mozilla.gecko.sync.repositories.delegates.RepositorySessionFetchRecordsDelegate;
 import org.mozilla.gecko.sync.repositories.delegates.RepositorySessionFinishDelegate;
 import org.mozilla.gecko.sync.repositories.delegates.RepositorySessionGuidsSinceDelegate;
 import org.mozilla.gecko.sync.repositories.delegates.RepositorySessionWipeDelegate;
 import org.mozilla.gecko.sync.repositories.domain.Record;
 import android.content.Context;
 public class WBORepository extends Repository {
   public class WBORepositoryStats {
     public long created         = -1;
     public long begun           = -1;
     public long fetchBegan      = -1;
     public long fetchCompleted  = -1;
     public long storeBegan      = -1;
     public long storeCompleted  = -1;
     public long finished        = -1;
   }
   public static final String LOG_TAG = "WBORepository";
   // Access to stats is not guarded.
   public WBORepositoryStats stats;
   // Whether or not to increment the timestamp of stored records.
   public final boolean bumpTimestamps;
   public class WBORepositorySession extends StoreTrackingRepositorySession {
     protected WBORepository wboRepository;
     protected ExecutorService delegateExecutor = Executors.newSingleThreadExecutor();
     public ConcurrentHashMap<String, Record> wbos;
     public WBORepositorySession(WBORepository repository) {
       super(repository);
       wboRepository = repository;
       wbos          = new ConcurrentHashMap<String, Record>();
       stats         = new WBORepositoryStats();
       stats.created = now();
     }
     @Override
     protected synchronized void trackGUID(String guid) {
       if (wboRepository.shouldTrack()) {
         super.trackGUID(guid);
       }
     }
     @Override
     public void guidsSince(long timestamp,
                            RepositorySessionGuidsSinceDelegate delegate) {
       throw new RuntimeException("guidsSince not implemented.");
     }
     @Override
     public void fetchSince(long timestamp,
                            RepositorySessionFetchRecordsDelegate delegate) {
       long fetchBegan  = now();
       stats.fetchBegan = fetchBegan;
       RecordFilter filter = storeTracker.getFilter();
       for (Entry<String, Record> entry : wbos.entrySet()) {
         Record record = entry.getValue();
         if (record.lastModified >= timestamp) {
           if (filter != null &&
               filter.excludeRecord(record)) {
             Logger.debug(LOG_TAG, "Excluding record " + record.guid);
             continue;
           }
           delegate.deferredFetchDelegate(delegateExecutor).onFetchedRecord(record);
         }
       }
       long fetchCompleted  = now();
       stats.fetchCompleted = fetchCompleted;
       delegate.deferredFetchDelegate(delegateExecutor).onFetchCompleted(fetchCompleted);
     }
     @Override
     public void fetch(final String[] guids,
                       final RepositorySessionFetchRecordsDelegate delegate) {
       long fetchBegan  = now();
       stats.fetchBegan = fetchBegan;
       for (String guid : guids) {
         if (wbos.containsKey(guid)) {
           delegate.deferredFetchDelegate(delegateExecutor).onFetchedRecord(wbos.get(guid));
         }
       }
       long fetchCompleted  = now();
       stats.fetchCompleted = fetchCompleted;
       delegate.deferredFetchDelegate(delegateExecutor).onFetchCompleted(fetchCompleted);
     }
     @Override
     public void fetchAll(final RepositorySessionFetchRecordsDelegate delegate) {
       long fetchBegan  = now();
       stats.fetchBegan = fetchBegan;
       for (Entry<String, Record> entry : wbos.entrySet()) {
         Record record = entry.getValue();
         delegate.deferredFetchDelegate(delegateExecutor).onFetchedRecord(record);
       }
       long fetchCompleted  = now();
       stats.fetchCompleted = fetchCompleted;
       delegate.deferredFetchDelegate(delegateExecutor).onFetchCompleted(fetchCompleted);
     }
     @Override
     public void store(final Record record) throws NoStoreDelegateException {
       if (delegate == null) {
         throw new NoStoreDelegateException();
       }
       final long now = now();
       if (stats.storeBegan < 0) {
         stats.storeBegan = now;
       }
       Record existing = wbos.get(record.guid);
       Logger.debug(LOG_TAG, "Existing record is " + (existing == null ? "<null>" : (existing.guid + ", " + existing)));
       if (existing != null &&
           existing.lastModified > record.lastModified) {
         Logger.debug(LOG_TAG, "Local record is newer. Not storing.");
         delegate.deferredStoreDelegate(delegateExecutor).onRecordStoreSucceeded(record.guid);
         return;
       }
       if (existing != null) {
         Logger.debug(LOG_TAG, "Replacing local record.");
       }
       // Store a copy of the record with an updated modified time.
       Record toStore = record.copyWithIDs(record.guid, record.androidID);
       if (bumpTimestamps) {
         toStore.lastModified = now;
       }
       wbos.put(record.guid, toStore);
       trackRecord(toStore);
       delegate.deferredStoreDelegate(delegateExecutor).onRecordStoreSucceeded(record.guid);
     }
     @Override
     public void wipe(final RepositorySessionWipeDelegate delegate) {
       if (!isActive()) {
         delegate.onWipeFailed(new InactiveSessionException(null));
         return;
       }
       Logger.info(LOG_TAG, "Wiping WBORepositorySession.");
       this.wbos = new ConcurrentHashMap<String, Record>();
       // Wipe immediately for the convenience of test code.
       wboRepository.wbos = new ConcurrentHashMap<String, Record>();
       delegate.deferredWipeDelegate(delegateExecutor).onWipeSucceeded();
     }
     @Override
     public void finish(RepositorySessionFinishDelegate delegate) throws InactiveSessionException {
       Logger.info(LOG_TAG, "Finishing WBORepositorySession: handing back " + this.wbos.size() + " WBOs.");
       wboRepository.wbos = this.wbos;
       stats.finished = now();
       super.finish(delegate);
     }
     @Override
     public void begin(RepositorySessionBeginDelegate delegate) throws InvalidSessionTransitionException {
       this.wbos = wboRepository.cloneWBOs();
       stats.begun = now();
       super.begin(delegate);
     }
     @Override
     public void storeDone(long end) {
       // TODO: this is not guaranteed to be called after all of the record
       // store callbacks have completed!
       if (stats.storeBegan < 0) {
         stats.storeBegan = end;
       }
       stats.storeCompleted = end;
       delegate.deferredStoreDelegate(delegateExecutor).onStoreCompleted(end);
     }
   }
   public ConcurrentHashMap<String, Record> wbos;
   public WBORepository(boolean bumpTimestamps) {
     super();
     this.bumpTimestamps = bumpTimestamps;
     this.wbos = new ConcurrentHashMap<String, Record>();
   }
   public WBORepository() {
     this(false);
   }
   public synchronized boolean shouldTrack() {
     return false;
   }
   @Override
   public void createSession(RepositorySessionCreationDelegate delegate,
                             Context context) {
     delegate.deferredCreationDelegate().onSessionCreated(new WBORepositorySession(this));
   }
   public ConcurrentHashMap<String, Record> cloneWBOs() {
     ConcurrentHashMap<String, Record> out = new ConcurrentHashMap<String, Record>();
     for (Entry<String, Record> entry : wbos.entrySet()) {
       out.put(entry.getKey(), entry.getValue()); // Assume that records are
                                                  // immutable.
     }
     return out;
   }
 }

The Tor Browser / annotate

mobile/android/tests/background/junit3/src/testhelpers/WBORepository.java@6474c204b198 (annotated)

mobile/android/tests/background/junit3/src/testhelpers/WBORepository.java