Move Java Blimp shell code to app subpackage

blimp/client/app/android/javatests/src/org/chromium/blimp/app/auth/RetryingTokenSourceTest.java

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-package org.chromium.blimp.auth;
+package org.chromium.blimp.app.auth;
 
 import android.content.Intent;
 import android.test.InstrumentationTestCase;
 import android.test.suitebuilder.annotation.SmallTest;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.Semaphore;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicReference;
@@ skipping 86 matching lines @@
          * @return      A small delay to be used during testing.
          */
         @Override
         protected int finalizeRetryDelay(int delay) {
             mRetryDelays.add(delay);
             return 1;
         }
     }
 
     private AtomicReference<TestRetryingTokenSource> buildAndTriggerTokenSource(
-            final String correctToken,
-            final int transientFailures,
-            final boolean hardFailure,
-            final Semaphore successSemaphore,
-            final Semaphore failureSemaphore,
+            final String correctToken, final int transientFailures, final boolean hardFailure,
+            final Semaphore successSemaphore, final Semaphore failureSemaphore,
             final Semaphore needsAccountSemaphore) {
         final AtomicReference<TestRetryingTokenSource> tokenSource =
                 new AtomicReference<TestRetryingTokenSource>();
         getInstrumentation().runOnMainSync(new Runnable() {
             @Override
             public void run() {
                 TokenSource mockTokenSource =
                         new MockTokenSource(correctToken, transientFailures, hardFailure);
-                tokenSource.set(new TestRetryingTokenSource(mockTokenSource,
-                        successSemaphore, failureSemaphore, needsAccountSemaphore));
+                tokenSource.set(new TestRetryingTokenSource(mockTokenSource, successSemaphore,
+                        failureSemaphore, needsAccountSemaphore));
                 tokenSource.get().getToken();
                 assertTrue("RetryingTokenSource is not attempting to get a token.",
                         tokenSource.get().isRetrievingToken());
             }
         });
         return tokenSource;
     }
 
     private void validateTokenSourceResults(
-            final AtomicReference<TestRetryingTokenSource> tokenSource,
-            final String expectedToken,
+            final AtomicReference<TestRetryingTokenSource> tokenSource, final String expectedToken,
             final int expectedTransientFailures) {
         getInstrumentation().runOnMainSync(new Runnable() {
             @Override
             public void run() {
                 String token = tokenSource.get().getReceivedToken();
                 assertEquals("getToken() resulted in the wrong token.", expectedToken, token);
 
                 List<Integer> delays = tokenSource.get().getRetryDelays();
                 assertEquals("getToken() resulted in an incorrect number of retries.",
                         expectedTransientFailures + 1, delays.size());
 
                 Integer prevDelay = Integer.MIN_VALUE;
                 for (int i = 0; i < delays.size(); i++) {
                     Integer delay = delays.get(i);
                     assertTrue("RetryingTokenSource did not increase delays between attempts "
-                            + "(" + prevDelay + " < " + delay + " failed).",
+                                    + "(" + prevDelay + " < " + delay + " failed).",
                             prevDelay < delay);
-                    assertTrue("RetryingTokenSource used a negative delay.",
-                            delay >= 0);
-                    assertTrue("RetryingTokenSource used no delay for retries.",
-                            delay > 0 || i == 0);
+                    assertTrue("RetryingTokenSource used a negative delay.", delay >= 0);
+                    assertTrue(
+                            "RetryingTokenSource used no delay for retries.", delay > 0 || i == 0);
                     prevDelay = delay;
                 }
             }
         });
     }
 
     /**
      * Tests basic behavior when the token is returned successfully.
      * @throws InterruptedException
      */
@@ skipping 19 matching lines @@
      * returned successfully.
      * @throws InterruptedException
      */
     @SmallTest
     public void testRecoveringTokenSource() throws InterruptedException {
         int failureCount = 6;
 
         Semaphore success = new Semaphore(0);
         Semaphore failure = new Semaphore(0);
         Semaphore needsAccount = new Semaphore(0);
-        AtomicReference<TestRetryingTokenSource> tokenSource =
-                buildAndTriggerTokenSource(TEST_TOKEN, failureCount, false, success, failure,
-                        needsAccount);
+        AtomicReference<TestRetryingTokenSource> tokenSource = buildAndTriggerTokenSource(
+                TEST_TOKEN, failureCount, false, success, failure, needsAccount);
 
         assertTrue("Did not receive a successful token in time.",
                 success.tryAcquire(SEMAPHORE_TIMEOUT_MS, TimeUnit.MILLISECONDS));
         assertFalse("getToken() failed.", failure.tryAcquire());
         assertFalse("getToken() needed an account.", needsAccount.tryAcquire());
 
         validateTokenSourceResults(tokenSource, TEST_TOKEN, failureCount);
     }
 
     /**
      * Tests failure behavior for when there is an unrecoverable error after multiple transient
      * errors.
      * @throws InterruptedException
      */
     @SmallTest
     public void testFailedTokenSource() throws InterruptedException {
         int failureCount = 6;
 
         Semaphore success = new Semaphore(0);
         Semaphore failure = new Semaphore(0);
         Semaphore needsAccount = new Semaphore(0);
-        AtomicReference<TestRetryingTokenSource> tokenSource =
-                buildAndTriggerTokenSource(TEST_TOKEN, failureCount, true, success, failure,
-                        needsAccount);
+        AtomicReference<TestRetryingTokenSource> tokenSource = buildAndTriggerTokenSource(
+                TEST_TOKEN, failureCount, true, success, failure, needsAccount);
 
         assertTrue("Did not receive a failure in time.",
                 failure.tryAcquire(SEMAPHORE_TIMEOUT_MS, TimeUnit.MILLISECONDS));
         assertFalse("getToken() succeeded.", success.tryAcquire());
         assertFalse("getToken() needed an account.", needsAccount.tryAcquire());
 
         validateTokenSourceResults(tokenSource, null, failureCount);
     }
 
     /**
      * Tests failure behavior for when there is an unrecoverable error after multiple transient
      * errors.
      * @throws InterruptedException
      */
     @SmallTest
     public void testTooManyTransientFailures() throws InterruptedException {
         int failureCount = RetryingTokenSource.MAX_NUMBER_OF_RETRIES + 1;
 
         Semaphore success = new Semaphore(0);
         Semaphore failure = new Semaphore(0);
         Semaphore needsAccount = new Semaphore(0);
-        AtomicReference<TestRetryingTokenSource> tokenSource =
-                buildAndTriggerTokenSource(TEST_TOKEN, failureCount, false, success, failure,
-                        needsAccount);
+        AtomicReference<TestRetryingTokenSource> tokenSource = buildAndTriggerTokenSource(
+                TEST_TOKEN, failureCount, false, success, failure, needsAccount);
 
         assertTrue("Did not receive a failure in time.",
                 failure.tryAcquire(SEMAPHORE_TIMEOUT_MS, TimeUnit.MILLISECONDS));
         assertFalse("getToken() succeeded.", success.tryAcquire());
         assertFalse("getToken() needed an account.", needsAccount.tryAcquire());
 
         // Expect one less transient error than MAX_NUMBER_OF_RETRIES.
         validateTokenSourceResults(
                 tokenSource, null, RetryingTokenSource.MAX_NUMBER_OF_RETRIES - 1);
     }
 }