The Tor Browser: mobile/android/base/sync/middleware/MiddlewareRepositorySession.java@fc2d59ddac77

     1 /* This Source Code Form is subject to the terms of the Mozilla Public

     2  * License, v. 2.0. If a copy of the MPL was not distributed with this

     3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

     5 package org.mozilla.gecko.sync.middleware;

     7 import java.util.concurrent.ExecutorService;

     9 import org.mozilla.gecko.background.common.log.Logger;

    10 import org.mozilla.gecko.sync.repositories.InactiveSessionException;

    11 import org.mozilla.gecko.sync.repositories.InvalidSessionTransitionException;

    12 import org.mozilla.gecko.sync.repositories.RepositorySession;

    13 import org.mozilla.gecko.sync.repositories.RepositorySessionBundle;

    14 import org.mozilla.gecko.sync.repositories.delegates.RepositorySessionBeginDelegate;

    15 import org.mozilla.gecko.sync.repositories.delegates.RepositorySessionFinishDelegate;

    16 import org.mozilla.gecko.sync.repositories.delegates.RepositorySessionGuidsSinceDelegate;

    17 import org.mozilla.gecko.sync.repositories.delegates.RepositorySessionWipeDelegate;

    19 public abstract class MiddlewareRepositorySession extends RepositorySession {

    20   private static final String LOG_TAG = "MiddlewareSession";

    21   protected final RepositorySession inner;

    23   public MiddlewareRepositorySession(RepositorySession innerSession, MiddlewareRepository repository) {

    24     super(repository);

    25     this.inner = innerSession;

    26   }

    28   @Override

    29   public void wipe(RepositorySessionWipeDelegate delegate) {

    30     inner.wipe(delegate);

    31   }

    33   public class MiddlewareRepositorySessionBeginDelegate implements RepositorySessionBeginDelegate {

    35     private MiddlewareRepositorySession outerSession;

    36     private RepositorySessionBeginDelegate next;

    38     public MiddlewareRepositorySessionBeginDelegate(MiddlewareRepositorySession outerSession, RepositorySessionBeginDelegate next) {

    39       this.outerSession = outerSession;

    40       this.next = next;

    41     }

    43     @Override

    44     public void onBeginFailed(Exception ex) {

    45       next.onBeginFailed(ex);

    46     }

    48     @Override

    49     public void onBeginSucceeded(RepositorySession session) {

    50       next.onBeginSucceeded(outerSession);

    51     }

    53     @Override

    54     public RepositorySessionBeginDelegate deferredBeginDelegate(ExecutorService executor) {

    55       final RepositorySessionBeginDelegate deferred = next.deferredBeginDelegate(executor);

    56       return new RepositorySessionBeginDelegate() {

    57         @Override

    58         public void onBeginSucceeded(RepositorySession session) {

    59           if (inner != session) {

    60             Logger.warn(LOG_TAG, "Got onBeginSucceeded for session " + session + ", not our inner session!");

    61           }

    62           deferred.onBeginSucceeded(outerSession);

    63         }

    65         @Override

    66         public void onBeginFailed(Exception ex) {

    67           deferred.onBeginFailed(ex);

    68         }

    70         @Override

    71         public RepositorySessionBeginDelegate deferredBeginDelegate(ExecutorService executor) {

    72           return this;

    73         }

    74       };

    75     }

    76   }

    78   public void begin(RepositorySessionBeginDelegate delegate) throws InvalidSessionTransitionException {

    79     inner.begin(new MiddlewareRepositorySessionBeginDelegate(this, delegate));

    80   }

    82   public class MiddlewareRepositorySessionFinishDelegate implements RepositorySessionFinishDelegate {

    83     private final MiddlewareRepositorySession outerSession;

    84     private final RepositorySessionFinishDelegate next;

    86     public MiddlewareRepositorySessionFinishDelegate(MiddlewareRepositorySession outerSession, RepositorySessionFinishDelegate next) {

    87       this.outerSession = outerSession;

    88       this.next = next;

    89     }

    91     @Override

    92     public void onFinishFailed(Exception ex) {

    93       next.onFinishFailed(ex);

    94     }

    96     @Override

    97     public void onFinishSucceeded(RepositorySession session, RepositorySessionBundle bundle) {

    98       next.onFinishSucceeded(outerSession, bundle);

    99     }

   101     @Override

   102     public RepositorySessionFinishDelegate deferredFinishDelegate(ExecutorService executor) {

   103       return this;

   104     }

   105   }

   107   @Override

   108   public void finish(RepositorySessionFinishDelegate delegate) throws InactiveSessionException {

   109     inner.finish(new MiddlewareRepositorySessionFinishDelegate(this, delegate));

   110   }

   113   @Override

   114   public synchronized void ensureActive() throws InactiveSessionException {

   115     inner.ensureActive();

   116   }

   118   @Override

   119   public synchronized boolean isActive() {

   120     return inner.isActive();

   121   }

   123   @Override

   124   public synchronized SessionStatus getStatus() {

   125     return inner.getStatus();

   126   }

   128   @Override

   129   public synchronized void setStatus(SessionStatus status) {

   130     inner.setStatus(status);

   131   }

   133   @Override

   134   public synchronized void transitionFrom(SessionStatus from, SessionStatus to)

   135       throws InvalidSessionTransitionException {

   136     inner.transitionFrom(from, to);

   137   }

   139   @Override

   140   public void abort() {

   141     inner.abort();

   142   }

   144   @Override

   145   public void abort(RepositorySessionFinishDelegate delegate) {

   146     inner.abort(new MiddlewareRepositorySessionFinishDelegate(this, delegate));

   147   }

   149   @Override

   150   public void guidsSince(long timestamp, RepositorySessionGuidsSinceDelegate delegate) {

   151     // TODO: need to do anything here?

   152     inner.guidsSince(timestamp, delegate);

   153   }

   155   @Override

   156   public void storeDone() {

   157     inner.storeDone();

   158   }

   160   @Override

   161   public void storeDone(long storeEnd) {

   162     inner.storeDone(storeEnd);

   163   }

   165   @Override

   166   public boolean shouldSkip() {

   167     return inner.shouldSkip();

   168   }

   170   @Override

   171   public boolean dataAvailable() {

   172     return inner.dataAvailable();

   173   }

   175   @Override

   176   public void unbundle(RepositorySessionBundle bundle) {

   177     inner.unbundle(bundle);

   178   }

   180   @Override

   181   public long getLastSyncTimestamp() {

   182     return inner.getLastSyncTimestamp();

   183   }

   184 }

The Tor Browser / file revision