src/chrome/android/sync_shell/javatests/src/chromium/chrome/browser/sync/FakeServerHelper.java

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 package org.chromium.chrome.browser.sync;
   6
   7 import android.content.Context;
   8
   9 import org.chromium.base.ThreadUtils;
  10 //import org.chromium.chrome.browser.sync.ProfileSyncService;
  11
  12 import java.util.concurrent.Callable;
  13
  14 /**
  15  * Assists in Java interaction the native Sync FakeServer.
  16  */
  17 public class FakeServerHelper {
  18     // Lazily-instantiated singleton FakeServerHelper.
  19     private static FakeServerHelper sFakeServerHelper;
  20
  21     // Pointer value for the FakeServer. This pointer is not owned by native
  22     // code, so it must be stored here for future deletion.
  23     private static long sNativeFakeServer = 0L;
  24
  25     // The pointer to the native object called here.
  26     private final long mNativeFakeServerHelperAndroid;
  27
  28     // Accesses the singleton FakeServerHelper. There is at most one instance created per
  29     // application lifetime, so no deletion mechanism is provided for the native object.
  30     public static FakeServerHelper get() {
  31         ThreadUtils.assertOnUiThread();
  32         if (sFakeServerHelper == null) {
  33             sFakeServerHelper = new FakeServerHelper();
  34         }
  35         return sFakeServerHelper;
  36     }
  37
  38     private FakeServerHelper() {
  39         mNativeFakeServerHelperAndroid = nativeInit();
  40     }
  41
  42     /**
  43      * Creates and configures FakeServer.
  44      *
  45      * Each call to this method should be accompanied by a later call to deleteFakeServer to avoid
  46      * a memory leak.
  47      */
  48     public static void useFakeServer(final Context context) {
  49         if (sNativeFakeServer != 0L) {
  50             throw new IllegalStateException(
  51                     "deleteFakeServer must be called before calling useFakeServer again.");
  52         }
  53
  54         sNativeFakeServer = ThreadUtils.runOnUiThreadBlockingNoException(new Callable<Long>() {
  55             @Override
  56             public Long call() {
  57                 FakeServerHelper fakeServerHelper = FakeServerHelper.get();
  58                 long nativeFakeServer = fakeServerHelper.createFakeServer();
  59                 long resources = fakeServerHelper.createNetworkResources(nativeFakeServer);
  60                 ProfileSyncService.get(context).overrideNetworkResourcesForTest(resources);
  61
  62                 return nativeFakeServer;
  63             }
  64         });
  65     }
  66
  67     /**
  68      * Deletes the existing FakeServer.
  69      */
  70     public static void deleteFakeServer() {
  71         if (sNativeFakeServer == 0L) {
  72             throw new IllegalStateException(
  73                     "useFakeServer must be called before calling deleteFakeServer.");
  74         }
  75
  76         ThreadUtils.runOnUiThreadBlockingNoException(new Callable<Void>() {
  77             @Override
  78             public Void call() {
  79                 FakeServerHelper.get().deleteFakeServer(sNativeFakeServer);
  80                 sNativeFakeServer = 0L;
  81                 return null;
  82             }
  83         });
  84     }
  85
  86     /**
  87      * Creates a native FakeServer object and returns its pointer. This pointer is owned by the
  88      * Java caller.
  89      *
  90      * @return the FakeServer pointer
  91      */
  92     public long createFakeServer() {
  93         return nativeCreateFakeServer(mNativeFakeServerHelperAndroid);
  94     }
  95
  96     /**
  97      * Creates a native NetworkResources object. This pointer is owned by the Java caller, but
  98      * ownership is transferred as part of ProfileSyncService.overrideNetworkResourcesForTest.
  99      *
 100      * @param nativeFakeServer pointer to a native FakeServer object.
 101      * @return the NetworkResources pointer
 102      */
 103     public long createNetworkResources(long nativeFakeServer) {
 104         return nativeCreateNetworkResources(mNativeFakeServerHelperAndroid, nativeFakeServer);
 105     }
 106
 107     /**
 108      * Deletes a native FakeServer.
 109      *
 110      * @param nativeFakeServer the pointer to be deleted
 111      */
 112     public void deleteFakeServer(long nativeFakeServer) {
 113         nativeDeleteFakeServer(mNativeFakeServerHelperAndroid, nativeFakeServer);
 114     }
 115
 116     // Native methods.
 117     private native long nativeInit();
 118     private native long nativeCreateFakeServer(long nativeFakeServerHelperAndroid);
 119     private native long nativeCreateNetworkResources(
 120             long nativeFakeServerHelperAndroid, long nativeFakeServer);
 121     private native void nativeDeleteFakeServer(
 122             long nativeFakeServerHelperAndroid, long nativeFakeServer);
 123 }