Upstream version 5.34.92.0
[platform/framework/web/crosswalk.git] / src / content / shell / android / javatests / src / org / chromium / content_shell_apk / ContentShellTestBase.java
1 // Copyright 2012 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.content_shell_apk;
6
7 import android.content.ComponentName;
8 import android.content.Intent;
9 import android.net.Uri;
10 import android.test.ActivityInstrumentationTestCase2;
11 import android.text.TextUtils;
12
13 import static org.chromium.base.test.util.ScalableTimeout.ScaleTimeout;
14
15 import org.chromium.base.test.util.UrlUtils;
16 import org.chromium.content.browser.ContentView;
17 import org.chromium.content.browser.ContentViewCore;
18 import org.chromium.content.browser.LoadUrlParams;
19 import org.chromium.content.browser.test.util.CallbackHelper;
20 import org.chromium.content.browser.test.util.Criteria;
21 import org.chromium.content.browser.test.util.CriteriaHelper;
22 import org.chromium.content.browser.test.util.TestCallbackHelperContainer;
23 import org.chromium.content_shell.Shell;
24
25 import java.util.concurrent.TimeUnit;
26 import java.util.concurrent.atomic.AtomicBoolean;
27
28 /**
29  * Base test class for all ContentShell based tests.
30  */
31 public class ContentShellTestBase extends ActivityInstrumentationTestCase2<ContentShellActivity> {
32
33     /** The maximum time the waitForActiveShellToBeDoneLoading method will wait. */
34     private static final long WAIT_FOR_ACTIVE_SHELL_LOADING_TIMEOUT = ScaleTimeout(10000);
35
36     protected static final long WAIT_PAGE_LOADING_TIMEOUT_SECONDS = ScaleTimeout(15);
37
38     public ContentShellTestBase() {
39         super(ContentShellActivity.class);
40     }
41
42     /**
43      * Starts the ContentShell activity and loads the given URL.
44      * The URL can be null, in which case will default to ContentShellActivity.DEFAULT_SHELL_URL.
45      */
46     protected ContentShellActivity launchContentShellWithUrl(String url) {
47         return launchContentShellWithUrlAndCommandLineArgs(url, null);
48     }
49
50     /**
51      * Starts the ContentShell activity appending the provided command line arguments
52      * and loads the given URL. The URL can be null, in which case will default to
53      * ContentShellActivity.DEFAULT_SHELL_URL.
54      */
55     protected ContentShellActivity launchContentShellWithUrlAndCommandLineArgs(String url,
56             String[] commandLineArgs) {
57         Intent intent = new Intent(Intent.ACTION_MAIN);
58         intent.addCategory(Intent.CATEGORY_LAUNCHER);
59         intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
60         if (url != null) intent.setData(Uri.parse(url));
61         intent.setComponent(new ComponentName(getInstrumentation().getTargetContext(),
62               ContentShellActivity.class));
63         if (commandLineArgs != null) {
64             intent.putExtra(ContentShellActivity.COMMAND_LINE_ARGS_KEY, commandLineArgs);
65         }
66         setActivityIntent(intent);
67         return getActivity();
68     }
69
70     // TODO(cjhopman): These functions are inconsistent with launchContentShell***. Should be
71     // startContentShell*** and should use the url exactly without the getTestFileUrl call. Possibly
72     // these two ways of starting the activity (launch* and start*) should be merged into one.
73     /**
74      * Starts the content shell activity with the provided test url.
75      * The url is synchronously loaded.
76      * @param url Test url to load.
77      */
78     protected void startActivityWithTestUrl(String url) throws Throwable {
79         launchContentShellWithUrl(UrlUtils.getTestFileUrl(url));
80         assertNotNull(getActivity());
81         assertTrue(waitForActiveShellToBeDoneLoading());
82         assertEquals(UrlUtils.getTestFileUrl(url), getContentView().getUrl());
83     }
84
85     /**
86      * Starts the content shell activity with the provided test url and optional command line
87      * arguments to append.
88      * The url is synchronously loaded.
89      * @param url Test url to load.
90      * @param commandLineArgs Optional command line args to append when launching the activity.
91      */
92     protected void startActivityWithTestUrlAndCommandLineArgs(
93             String url, String[] commandLineArgs) throws Throwable {
94         launchContentShellWithUrlAndCommandLineArgs(
95                 UrlUtils.getTestFileUrl(url), commandLineArgs);
96         assertNotNull(getActivity());
97         assertTrue(waitForActiveShellToBeDoneLoading());
98     }
99
100     /**
101      * Returns the current ContentView.
102      */
103     protected ContentView getContentView() {
104         return getActivity().getActiveShell().getContentView();
105     }
106
107     /**
108      * Returns the current ContentViewCore or null if there is no ContentView.
109      */
110     protected ContentViewCore getContentViewCore() {
111         return getContentView() == null ? null : getContentView().getContentViewCore();
112     }
113
114     /**
115      * Waits for the Active shell to finish loading.  This times out after
116      * WAIT_FOR_ACTIVE_SHELL_LOADING_TIMEOUT milliseconds and it shouldn't be used for long
117      * loading pages. Instead it should be used more for test initialization. The proper way
118      * to wait is to use a TestCallbackHelperContainer after the initial load is completed.
119      * @return Whether or not the Shell was actually finished loading.
120      * @throws InterruptedException
121      */
122     protected boolean waitForActiveShellToBeDoneLoading() throws InterruptedException {
123         final ContentShellActivity activity = getActivity();
124
125         // Wait for the Content Shell to be initialized.
126         return CriteriaHelper.pollForCriteria(new Criteria() {
127             @Override
128             public boolean isSatisfied() {
129                 try {
130                     final AtomicBoolean isLoaded = new AtomicBoolean(false);
131                     runTestOnUiThread(new Runnable() {
132                         @Override
133                         public void run() {
134                             Shell shell = activity.getActiveShell();
135                             if (shell != null) {
136                                 // There are two cases here that need to be accounted for.
137                                 // The first is that we've just created a Shell and it isn't
138                                 // loading because it has no URL set yet.  The second is that
139                                 // we've set a URL and it actually is loading.
140                                 isLoaded.set(!shell.isLoading()
141                                         && !TextUtils.isEmpty(shell.getContentView().getUrl()));
142                             } else {
143                                 isLoaded.set(false);
144                             }
145                         }
146                     });
147
148                     return isLoaded.get();
149                 } catch (Throwable e) {
150                     return false;
151                 }
152             }
153         }, WAIT_FOR_ACTIVE_SHELL_LOADING_TIMEOUT, CriteriaHelper.DEFAULT_POLLING_INTERVAL);
154     }
155
156     /**
157      * Loads a URL in the specified content view.
158      *
159      * @param contentView The content view to load the URL in.
160      * @param callbackHelperContainer The callback helper container used to monitor progress.
161      * @param params The URL params to use.
162      */
163     protected void loadUrl(
164             final ContentView contentView, TestCallbackHelperContainer callbackHelperContainer,
165             final LoadUrlParams params) throws Throwable {
166         handleBlockingCallbackAction(
167                 callbackHelperContainer.getOnPageFinishedHelper(),
168                 new Runnable() {
169                     @Override
170                     public void run() {
171                         contentView.loadUrl(params);
172                     }
173                 });
174     }
175
176     /**
177      * Handles performing an action on the UI thread that will return when the specified callback
178      * is incremented.
179      *
180      * @param callbackHelper The callback helper that will be blocked on.
181      * @param action The action to be performed on the UI thread.
182      */
183     protected void handleBlockingCallbackAction(
184             CallbackHelper callbackHelper, Runnable action) throws Throwable {
185         int currentCallCount = callbackHelper.getCallCount();
186         runTestOnUiThread(action);
187         callbackHelper.waitForCallback(
188                 currentCallCount, 1, WAIT_PAGE_LOADING_TIMEOUT_SECONDS, TimeUnit.SECONDS);
189     }
190
191     // TODO(aelias): This method needs to be removed once http://crbug.com/179511 is fixed.
192     // Meanwhile, we have to wait if the page has the <meta viewport> tag.
193     /**
194      * Waits till the ContentViewCore receives the expected page scale factor
195      * from the compositor and asserts that this happens.
196      */
197     protected void assertWaitForPageScaleFactorMatch(final float expectedScale)
198             throws InterruptedException {
199         assertTrue(CriteriaHelper.pollForCriteria(new Criteria() {
200             @Override
201             public boolean isSatisfied() {
202                 return getContentViewCore().getScale() == expectedScale;
203             }
204         }));
205     }
206 }