зеркало из https://github.com/mozilla/gecko-dev.git
Bug 1512274 - [geckoview] Make all private member variable be mCamelCase. r=geckoview-reviewers,snorp
Differential Revision: https://phabricator.services.mozilla.com/D23687 --HG-- extra : moz-landing-system : lando
This commit is contained in:
Agi Sferro
Родитель
d2c60bfc54
Коммит
5ab4f6d887
|
|
@ -405,8 +405,8 @@ public final class EventDispatcher extends JNIObject {
|
|||
}
|
||||
|
||||
private static class JavaCallbackDelegate implements EventCallback {
|
||||
private final Thread originalThread = Thread.currentThread();
|
||||
private final EventCallback callback;
|
||||
private final Thread mOriginalThread = Thread.currentThread();
|
||||
private final EventCallback mCallback;
|
||||
|
||||
public static EventCallback wrap(final EventCallback callback) {
|
||||
if (callback == null) {
|
||||
|
|
@ -420,7 +420,7 @@ public final class EventDispatcher extends JNIObject {
|
|||
}
|
||||
|
||||
JavaCallbackDelegate(final EventCallback callback) {
|
||||
this.callback = callback;
|
||||
mCallback = callback;
|
||||
}
|
||||
|
||||
private void makeCallback(final boolean callSuccess, final Object rawResponse) {
|
||||
|
|
@ -445,11 +445,11 @@ public final class EventDispatcher extends JNIObject {
|
|||
|
||||
// Call back synchronously if we happen to be on the same thread as the thread
|
||||
// making the original request.
|
||||
if (ThreadUtils.isOnThread(originalThread)) {
|
||||
if (ThreadUtils.isOnThread(mOriginalThread)) {
|
||||
if (callSuccess) {
|
||||
callback.sendSuccess(response);
|
||||
mCallback.sendSuccess(response);
|
||||
} else {
|
||||
callback.sendError(response);
|
||||
mCallback.sendError(response);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
|
@ -457,10 +457,10 @@ public final class EventDispatcher extends JNIObject {
|
|||
// Make callback on the thread of the original request, if the original thread
|
||||
// is the UI or Gecko thread. Otherwise default to the background thread.
|
||||
final Handler handler =
|
||||
originalThread == ThreadUtils.getUiThread() ? ThreadUtils.getUiHandler() :
|
||||
originalThread == ThreadUtils.sGeckoThread ? ThreadUtils.sGeckoHandler :
|
||||
mOriginalThread == ThreadUtils.getUiThread() ? ThreadUtils.getUiHandler() :
|
||||
mOriginalThread == ThreadUtils.sGeckoThread ? ThreadUtils.sGeckoHandler :
|
||||
ThreadUtils.getBackgroundHandler();
|
||||
final EventCallback callback = this.callback;
|
||||
final EventCallback callback = mCallback;
|
||||
|
||||
handler.post(new Runnable() {
|
||||
@Override
|
||||
|
|
|
|||
|
|
@ -1767,11 +1767,11 @@ public class GeckoAppShell
|
|||
}
|
||||
|
||||
private static class BitmapConnection extends URLConnection {
|
||||
private Bitmap bitmap;
|
||||
private Bitmap mBitmap;
|
||||
|
||||
BitmapConnection(final Bitmap b) throws MalformedURLException, IOException {
|
||||
super(null);
|
||||
bitmap = b;
|
||||
mBitmap = b;
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
@ -1806,7 +1806,7 @@ public class GeckoAppShell
|
|||
@Override
|
||||
public void run() {
|
||||
try {
|
||||
bitmap.compress(Bitmap.CompressFormat.PNG, 100, output);
|
||||
mBitmap.compress(Bitmap.CompressFormat.PNG, 100, output);
|
||||
} finally {
|
||||
IOUtils.safeStreamClose(output);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -55,7 +55,7 @@ public class GeckoNetworkManager extends BroadcastReceiver implements BundleEven
|
|||
|
||||
// We hackishly (yet harmlessly, in this case) keep a Context reference passed in via the start method.
|
||||
// See context handling notes in handleManagerEvent, and Bug 1277333.
|
||||
private Context context;
|
||||
private Context mContext;
|
||||
|
||||
public static void destroy() {
|
||||
if (instance != null) {
|
||||
|
|
@ -79,13 +79,13 @@ public class GeckoNetworkManager extends BroadcastReceiver implements BundleEven
|
|||
receivedUpdate
|
||||
}
|
||||
|
||||
private ManagerState currentState = ManagerState.OffNoListeners;
|
||||
private ConnectionType currentConnectionType = ConnectionType.NONE;
|
||||
private ConnectionType previousConnectionType = ConnectionType.NONE;
|
||||
private ConnectionSubType currentConnectionSubtype = ConnectionSubType.UNKNOWN;
|
||||
private ConnectionSubType previousConnectionSubtype = ConnectionSubType.UNKNOWN;
|
||||
private NetworkStatus currentNetworkStatus = NetworkStatus.UNKNOWN;
|
||||
private NetworkStatus previousNetworkStatus = NetworkStatus.UNKNOWN;
|
||||
private ManagerState mCurrentState = ManagerState.OffNoListeners;
|
||||
private ConnectionType mCurrentConnectionType = ConnectionType.NONE;
|
||||
private ConnectionType mPreviousConnectionType = ConnectionType.NONE;
|
||||
private ConnectionSubType mCurrentConnectionSubtype = ConnectionSubType.UNKNOWN;
|
||||
private ConnectionSubType mPreviousConnectionSubtype = ConnectionSubType.UNKNOWN;
|
||||
private NetworkStatus mCurrentNetworkStatus = NetworkStatus.UNKNOWN;
|
||||
private NetworkStatus mPreviousNetworkStatus = NetworkStatus.UNKNOWN;
|
||||
|
||||
private enum InfoType {
|
||||
MCC,
|
||||
|
|
@ -115,7 +115,7 @@ public class GeckoNetworkManager extends BroadcastReceiver implements BundleEven
|
|||
|
||||
public double[] getCurrentInformation() {
|
||||
final Context applicationContext = GeckoAppShell.getApplicationContext();
|
||||
final ConnectionType connectionType = currentConnectionType;
|
||||
final ConnectionType connectionType = mCurrentConnectionType;
|
||||
return new double[] {
|
||||
connectionType.value,
|
||||
connectionType == ConnectionType.WIFI ? 1.0 : 0.0,
|
||||
|
|
@ -129,7 +129,7 @@ public class GeckoNetworkManager extends BroadcastReceiver implements BundleEven
|
|||
}
|
||||
|
||||
public void start(final Context context) {
|
||||
this.context = context;
|
||||
mContext = context;
|
||||
handleManagerEvent(ManagerEvent.start);
|
||||
}
|
||||
|
||||
|
|
@ -153,11 +153,11 @@ public class GeckoNetworkManager extends BroadcastReceiver implements BundleEven
|
|||
* @return Boolean indicating if transition was performed.
|
||||
*/
|
||||
private synchronized boolean handleManagerEvent(final ManagerEvent event) {
|
||||
final ManagerState nextState = getNextState(currentState, event);
|
||||
final ManagerState nextState = getNextState(mCurrentState, event);
|
||||
|
||||
Log.d(LOGTAG, "Incoming event " + event + " for state " + currentState + " -> " + nextState);
|
||||
Log.d(LOGTAG, "Incoming event " + event + " for state " + mCurrentState + " -> " + nextState);
|
||||
if (nextState == null) {
|
||||
Log.w(LOGTAG, "Invalid event " + event + " for state " + currentState);
|
||||
Log.w(LOGTAG, "Invalid event " + event + " for state " + mCurrentState);
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -169,19 +169,19 @@ public class GeckoNetworkManager extends BroadcastReceiver implements BundleEven
|
|||
// seems to be how this class fits into the larger ecosystem and general flow of events.
|
||||
// See Bug 1277333.
|
||||
final Context contextForAction;
|
||||
if (context != null) {
|
||||
contextForAction = context;
|
||||
if (mContext != null) {
|
||||
contextForAction = mContext;
|
||||
} else {
|
||||
contextForAction = GeckoAppShell.getApplicationContext();
|
||||
}
|
||||
|
||||
if (contextForAction == null) {
|
||||
Log.w(LOGTAG, "Context is not available while processing event " + event + " for state " + currentState);
|
||||
Log.w(LOGTAG, "Context is not available while processing event " + event + " for state " + mCurrentState);
|
||||
return false;
|
||||
}
|
||||
|
||||
performActionsForStateEvent(contextForAction, currentState, event);
|
||||
currentState = nextState;
|
||||
performActionsForStateEvent(contextForAction, mCurrentState, event);
|
||||
mCurrentState = nextState;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
|
@ -309,10 +309,10 @@ public class GeckoNetworkManager extends BroadcastReceiver implements BundleEven
|
|||
if (connectivityManager == null) {
|
||||
Log.e(LOGTAG, "ConnectivityManager does not exist.");
|
||||
}
|
||||
currentConnectionType = NetworkUtils.getConnectionType(connectivityManager);
|
||||
currentNetworkStatus = NetworkUtils.getNetworkStatus(connectivityManager);
|
||||
currentConnectionSubtype = NetworkUtils.getConnectionSubType(connectivityManager);
|
||||
Log.d(LOGTAG, "New network state: " + currentNetworkStatus + ", " + currentConnectionType + ", " + currentConnectionSubtype);
|
||||
mCurrentConnectionType = NetworkUtils.getConnectionType(connectivityManager);
|
||||
mCurrentNetworkStatus = NetworkUtils.getNetworkStatus(connectivityManager);
|
||||
mCurrentConnectionSubtype = NetworkUtils.getConnectionSubType(connectivityManager);
|
||||
Log.d(LOGTAG, "New network state: " + mCurrentNetworkStatus + ", " + mCurrentConnectionType + ", " + mCurrentConnectionSubtype);
|
||||
}
|
||||
|
||||
@WrapForJNI(dispatchTo = "gecko")
|
||||
|
|
@ -326,40 +326,40 @@ public class GeckoNetworkManager extends BroadcastReceiver implements BundleEven
|
|||
* Send current network state and connection type to whomever is listening.
|
||||
*/
|
||||
private void sendNetworkStateToListeners(final Context context) {
|
||||
final boolean connectionTypeOrSubtypeChanged = currentConnectionType != previousConnectionType ||
|
||||
currentConnectionSubtype != previousConnectionSubtype;
|
||||
final boolean connectionTypeOrSubtypeChanged = mCurrentConnectionType != mPreviousConnectionType ||
|
||||
mCurrentConnectionSubtype != mPreviousConnectionSubtype;
|
||||
if (connectionTypeOrSubtypeChanged) {
|
||||
previousConnectionType = currentConnectionType;
|
||||
previousConnectionSubtype = currentConnectionSubtype;
|
||||
mPreviousConnectionType = mCurrentConnectionType;
|
||||
mPreviousConnectionSubtype = mCurrentConnectionSubtype;
|
||||
|
||||
final boolean isWifi = currentConnectionType == ConnectionType.WIFI;
|
||||
final boolean isWifi = mCurrentConnectionType == ConnectionType.WIFI;
|
||||
final int gateway = !isWifi ? 0 :
|
||||
wifiDhcpGatewayAddress(context);
|
||||
|
||||
if (GeckoThread.isRunning()) {
|
||||
onConnectionChanged(currentConnectionType.value,
|
||||
currentConnectionSubtype.value, isWifi, gateway);
|
||||
onConnectionChanged(mCurrentConnectionType.value,
|
||||
mCurrentConnectionSubtype.value, isWifi, gateway);
|
||||
} else {
|
||||
GeckoThread.queueNativeCall(GeckoNetworkManager.class, "onConnectionChanged",
|
||||
currentConnectionType.value,
|
||||
String.class, currentConnectionSubtype.value,
|
||||
mCurrentConnectionType.value,
|
||||
String.class, mCurrentConnectionSubtype.value,
|
||||
isWifi, gateway);
|
||||
}
|
||||
}
|
||||
|
||||
// If neither network status nor network configuration changed, do nothing.
|
||||
if (currentNetworkStatus == previousNetworkStatus && !connectionTypeOrSubtypeChanged) {
|
||||
if (mCurrentNetworkStatus == mPreviousNetworkStatus && !connectionTypeOrSubtypeChanged) {
|
||||
return;
|
||||
}
|
||||
|
||||
// If network status remains the same, send "changed". Otherwise, send new network status.
|
||||
// See Bug 1330836 for relevant details.
|
||||
final String status;
|
||||
if (currentNetworkStatus == previousNetworkStatus) {
|
||||
if (mCurrentNetworkStatus == mPreviousNetworkStatus) {
|
||||
status = LINK_DATA_CHANGED;
|
||||
} else {
|
||||
previousNetworkStatus = currentNetworkStatus;
|
||||
status = currentNetworkStatus.value;
|
||||
mPreviousNetworkStatus = mCurrentNetworkStatus;
|
||||
status = mCurrentNetworkStatus.value;
|
||||
}
|
||||
|
||||
if (GeckoThread.isRunning()) {
|
||||
|
|
|
|||
|
|
@ -27,7 +27,7 @@ public class GeckoSystemStateListener
|
|||
|
||||
private static final GeckoSystemStateListener listenerInstance = new GeckoSystemStateListener();
|
||||
|
||||
private boolean initialized;
|
||||
private boolean mInitialized;
|
||||
private ContentObserver mContentObserver;
|
||||
private static Context sApplicationContext;
|
||||
private InputManager mInputManager;
|
||||
|
|
@ -40,7 +40,7 @@ public class GeckoSystemStateListener
|
|||
}
|
||||
|
||||
public synchronized void initialize(final Context context) {
|
||||
if (initialized) {
|
||||
if (mInitialized) {
|
||||
Log.w(LOGTAG, "Already initialized!");
|
||||
return;
|
||||
}
|
||||
|
|
@ -59,11 +59,11 @@ public class GeckoSystemStateListener
|
|||
};
|
||||
contentResolver.registerContentObserver(animationSetting, false, mContentObserver);
|
||||
|
||||
initialized = true;
|
||||
mInitialized = true;
|
||||
}
|
||||
|
||||
public synchronized void shutdown() {
|
||||
if (!initialized) {
|
||||
if (!mInitialized) {
|
||||
Log.w(LOGTAG, "Already shut down!");
|
||||
return;
|
||||
}
|
||||
|
|
@ -78,7 +78,7 @@ public class GeckoSystemStateListener
|
|||
ContentResolver contentResolver = sApplicationContext.getContentResolver();
|
||||
contentResolver.unregisterContentObserver(mContentObserver);
|
||||
|
||||
initialized = false;
|
||||
mInitialized = false;
|
||||
mInputManager = null;
|
||||
mContentObserver = null;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -69,10 +69,10 @@ public class GeckoThread extends Thread {
|
|||
* components are shut down and become unavailable. EXITING has the same rank as
|
||||
* LIBS_READY because both states have a similar amount of components available.
|
||||
*/
|
||||
private final int rank;
|
||||
private final int mRank;
|
||||
|
||||
private State(final int rank) {
|
||||
this.rank = rank;
|
||||
mRank = rank;
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
@ -83,7 +83,7 @@ public class GeckoThread extends Thread {
|
|||
@Override
|
||||
public boolean isAtLeast(final NativeQueue.State other) {
|
||||
if (other instanceof State) {
|
||||
return this.rank >= ((State) other).rank;
|
||||
return mRank >= ((State) other).mRank;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -120,15 +120,15 @@ public interface TelemetryContract {
|
|||
_TEST4("_test_event_4.1"),
|
||||
;
|
||||
|
||||
private final String string;
|
||||
private final String mString;
|
||||
|
||||
Event(final String string) {
|
||||
this.string = string;
|
||||
mString = string;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return string;
|
||||
return mString;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -218,15 +218,15 @@ public interface TelemetryContract {
|
|||
_TEST2("_test_method_2"),
|
||||
;
|
||||
|
||||
private final String string;
|
||||
private final String mString;
|
||||
|
||||
Method(final String string) {
|
||||
this.string = string;
|
||||
mString = string;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return string;
|
||||
return mString;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -272,15 +272,15 @@ public interface TelemetryContract {
|
|||
_TEST_STOPPED_TWICE("_test_session_stopped_twice.1"),
|
||||
;
|
||||
|
||||
private final String string;
|
||||
private final String mString;
|
||||
|
||||
Session(final String string) {
|
||||
this.string = string;
|
||||
mString = string;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return string;
|
||||
return mString;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -303,15 +303,15 @@ public interface TelemetryContract {
|
|||
_TEST_IGNORED("_test_reason_ignored"),
|
||||
;
|
||||
|
||||
private final String string;
|
||||
private final String mString;
|
||||
|
||||
Reason(final String string) {
|
||||
this.string = string;
|
||||
mString = string;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return string;
|
||||
return mString;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -34,12 +34,12 @@ public final class GeckoHLSSample {
|
|||
@WrapForJNI
|
||||
final public CryptoInfo cryptoInfo;
|
||||
|
||||
private ByteBuffer buffer = null;
|
||||
private ByteBuffer mBuffer = null;
|
||||
|
||||
@WrapForJNI
|
||||
public void writeToByteBuffer(final ByteBuffer dest) throws IOException {
|
||||
if (buffer != null && dest != null && info.size > 0) {
|
||||
dest.put(buffer);
|
||||
if (mBuffer != null && dest != null && info.size > 0) {
|
||||
dest.put(mBuffer);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -62,7 +62,7 @@ public final class GeckoHLSSample {
|
|||
final CryptoInfo cryptoInfo, final int formatIndex) {
|
||||
this.formatIndex = formatIndex;
|
||||
duration = Long.MAX_VALUE;
|
||||
this.buffer = buffer;
|
||||
this.mBuffer = buffer;
|
||||
this.info = info;
|
||||
this.cryptoInfo = cryptoInfo;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -53,7 +53,7 @@ public abstract class GeckoHlsRendererBase extends BaseRenderer {
|
|||
|
||||
private DecoderInputBuffer mBufferForRead =
|
||||
new DecoderInputBuffer(DecoderInputBuffer.BUFFER_REPLACEMENT_MODE_NORMAL);
|
||||
private final DecoderInputBuffer mflagsOnlyBuffer = DecoderInputBuffer.newFlagsOnlyInstance();
|
||||
private final DecoderInputBuffer mFlagsOnlyBuffer = DecoderInputBuffer.newFlagsOnlyInstance();
|
||||
|
||||
protected void assertTrue(final boolean condition) {
|
||||
if (DEBUG && !condition) {
|
||||
|
|
@ -251,8 +251,8 @@ public abstract class GeckoHlsRendererBase extends BaseRenderer {
|
|||
}
|
||||
|
||||
private void readFormat() throws ExoPlaybackException {
|
||||
mflagsOnlyBuffer.clear();
|
||||
int result = readSource(mFormatHolder, mflagsOnlyBuffer, true);
|
||||
mFlagsOnlyBuffer.clear();
|
||||
int result = readSource(mFormatHolder, mFlagsOnlyBuffer, true);
|
||||
if (result == C.RESULT_FORMAT_READ) {
|
||||
onInputFormatChanged(mFormatHolder.format);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -23,16 +23,16 @@ import java.util.ArrayList;
|
|||
public class SafeIntent {
|
||||
private static final String LOGTAG = "Gecko" + SafeIntent.class.getSimpleName();
|
||||
|
||||
private final Intent intent;
|
||||
private final Intent mIntent;
|
||||
|
||||
public SafeIntent(final Intent intent) {
|
||||
stripDataUri(intent);
|
||||
this.intent = intent;
|
||||
mIntent = intent;
|
||||
}
|
||||
|
||||
public boolean hasExtra(final String name) {
|
||||
try {
|
||||
return intent.hasExtra(name);
|
||||
return mIntent.hasExtra(name);
|
||||
} catch (OutOfMemoryError e) {
|
||||
Log.w(LOGTAG, "Couldn't determine if intent had an extra: OOM. Malformed?");
|
||||
return false;
|
||||
|
|
@ -44,7 +44,7 @@ public class SafeIntent {
|
|||
|
||||
public @Nullable Bundle getExtras() {
|
||||
try {
|
||||
return intent.getExtras();
|
||||
return mIntent.getExtras();
|
||||
} catch (OutOfMemoryError e) {
|
||||
Log.w(LOGTAG, "Couldn't get intent extras: OOM. Malformed?");
|
||||
return null;
|
||||
|
|
@ -56,7 +56,7 @@ public class SafeIntent {
|
|||
|
||||
public boolean getBooleanExtra(final String name, final boolean defaultValue) {
|
||||
try {
|
||||
return intent.getBooleanExtra(name, defaultValue);
|
||||
return mIntent.getBooleanExtra(name, defaultValue);
|
||||
} catch (OutOfMemoryError e) {
|
||||
Log.w(LOGTAG, "Couldn't get intent extras: OOM. Malformed?");
|
||||
return defaultValue;
|
||||
|
|
@ -68,7 +68,7 @@ public class SafeIntent {
|
|||
|
||||
public int getIntExtra(final String name, final int defaultValue) {
|
||||
try {
|
||||
return intent.getIntExtra(name, defaultValue);
|
||||
return mIntent.getIntExtra(name, defaultValue);
|
||||
} catch (OutOfMemoryError e) {
|
||||
Log.w(LOGTAG, "Couldn't get intent extras: OOM. Malformed?");
|
||||
return defaultValue;
|
||||
|
|
@ -80,7 +80,7 @@ public class SafeIntent {
|
|||
|
||||
public String getStringExtra(final String name) {
|
||||
try {
|
||||
return intent.getStringExtra(name);
|
||||
return mIntent.getStringExtra(name);
|
||||
} catch (OutOfMemoryError e) {
|
||||
Log.w(LOGTAG, "Couldn't get intent extras: OOM. Malformed?");
|
||||
return null;
|
||||
|
|
@ -92,7 +92,7 @@ public class SafeIntent {
|
|||
|
||||
public Bundle getBundleExtra(final String name) {
|
||||
try {
|
||||
return intent.getBundleExtra(name);
|
||||
return mIntent.getBundleExtra(name);
|
||||
} catch (OutOfMemoryError e) {
|
||||
Log.w(LOGTAG, "Couldn't get intent extras: OOM. Malformed?");
|
||||
return null;
|
||||
|
|
@ -103,12 +103,12 @@ public class SafeIntent {
|
|||
}
|
||||
|
||||
public String getAction() {
|
||||
return intent.getAction();
|
||||
return mIntent.getAction();
|
||||
}
|
||||
|
||||
public String getDataString() {
|
||||
try {
|
||||
return intent.getDataString();
|
||||
return mIntent.getDataString();
|
||||
} catch (OutOfMemoryError e) {
|
||||
Log.w(LOGTAG, "Couldn't get intent data string: OOM. Malformed?");
|
||||
return null;
|
||||
|
|
@ -120,7 +120,7 @@ public class SafeIntent {
|
|||
|
||||
public ArrayList<String> getStringArrayListExtra(final String name) {
|
||||
try {
|
||||
return intent.getStringArrayListExtra(name);
|
||||
return mIntent.getStringArrayListExtra(name);
|
||||
} catch (OutOfMemoryError e) {
|
||||
Log.w(LOGTAG, "Couldn't get intent data string: OOM. Malformed?");
|
||||
return null;
|
||||
|
|
@ -132,7 +132,7 @@ public class SafeIntent {
|
|||
|
||||
public Uri getData() {
|
||||
try {
|
||||
return intent.getData();
|
||||
return mIntent.getData();
|
||||
} catch (OutOfMemoryError e) {
|
||||
Log.w(LOGTAG, "Couldn't get intent data: OOM. Malformed?");
|
||||
return null;
|
||||
|
|
@ -143,7 +143,7 @@ public class SafeIntent {
|
|||
}
|
||||
|
||||
public Intent getUnsafe() {
|
||||
return intent;
|
||||
return mIntent;
|
||||
}
|
||||
|
||||
private static void stripDataUri(final Intent intent) {
|
||||
|
|
|
|||
|
|
@ -15,26 +15,26 @@ import android.support.annotation.NonNull;
|
|||
* Helper class to run code blocks depending on whether a user has granted or denied certain runtime permissions.
|
||||
*/
|
||||
public class PermissionBlock {
|
||||
private final PermissionsHelper helper;
|
||||
private final PermissionsHelper mHelper;
|
||||
|
||||
private Context context;
|
||||
private String[] permissions;
|
||||
private boolean onUIThread;
|
||||
private boolean onBackgroundThread;
|
||||
private Runnable onPermissionsGranted;
|
||||
private Runnable onPermissionsDenied;
|
||||
private boolean doNotPrompt;
|
||||
private Context mContext;
|
||||
private String[] mPermissions;
|
||||
private boolean mOnUiThread;
|
||||
private boolean mOnBackgroundThread;
|
||||
private Runnable mOnPermissionsGranted;
|
||||
private Runnable mOnPermissionsDenied;
|
||||
private boolean mDoNotPrompt;
|
||||
|
||||
/* package-private */ PermissionBlock(final Context context, final PermissionsHelper helper) {
|
||||
this.context = context;
|
||||
this.helper = helper;
|
||||
mContext = context;
|
||||
mHelper = helper;
|
||||
}
|
||||
|
||||
/**
|
||||
* Determine whether the app has been granted the specified permissions.
|
||||
*/
|
||||
public PermissionBlock withPermissions(final @NonNull String... permissions) {
|
||||
this.permissions = permissions;
|
||||
mPermissions = permissions;
|
||||
return this;
|
||||
}
|
||||
|
||||
|
|
@ -42,7 +42,7 @@ public class PermissionBlock {
|
|||
* Execute all callbacks on the UI thread.
|
||||
*/
|
||||
public PermissionBlock onUIThread() {
|
||||
this.onUIThread = true;
|
||||
mOnUiThread = true;
|
||||
return this;
|
||||
}
|
||||
|
||||
|
|
@ -50,7 +50,7 @@ public class PermissionBlock {
|
|||
* Execute all callbacks on the background thread.
|
||||
*/
|
||||
public PermissionBlock onBackgroundThread() {
|
||||
this.onBackgroundThread = true;
|
||||
mOnBackgroundThread = true;
|
||||
return this;
|
||||
}
|
||||
|
||||
|
|
@ -60,7 +60,7 @@ public class PermissionBlock {
|
|||
* thread has been explicitly specified.
|
||||
*/
|
||||
public PermissionBlock doNotPrompt() {
|
||||
doNotPrompt = true;
|
||||
mDoNotPrompt = true;
|
||||
return this;
|
||||
}
|
||||
|
||||
|
|
@ -88,38 +88,38 @@ public class PermissionBlock {
|
|||
* user if needed.
|
||||
*/
|
||||
public void run(final Runnable onPermissionsGranted) {
|
||||
if (!doNotPrompt && !(context instanceof Activity)) {
|
||||
if (!mDoNotPrompt && !(mContext instanceof Activity)) {
|
||||
throw new IllegalStateException("You need to either specify doNotPrompt() or pass in an Activity context");
|
||||
}
|
||||
|
||||
this.onPermissionsGranted = onPermissionsGranted;
|
||||
mOnPermissionsGranted = onPermissionsGranted;
|
||||
|
||||
if (hasPermissions(context)) {
|
||||
if (hasPermissions(mContext)) {
|
||||
onPermissionsGranted();
|
||||
} else if (doNotPrompt) {
|
||||
} else if (mDoNotPrompt) {
|
||||
onPermissionsDenied();
|
||||
} else {
|
||||
Permissions.prompt((Activity) context, this);
|
||||
Permissions.prompt((Activity) mContext, this);
|
||||
}
|
||||
|
||||
// This reference is no longer needed. Let's clear it now to avoid memory leaks.
|
||||
context = null;
|
||||
mContext = null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Execute this fallback if at least one permission has not been granted.
|
||||
*/
|
||||
public PermissionBlock andFallback(final @NonNull Runnable onPermissionsDenied) {
|
||||
this.onPermissionsDenied = onPermissionsDenied;
|
||||
mOnPermissionsDenied = onPermissionsDenied;
|
||||
return this;
|
||||
}
|
||||
|
||||
/* package-private */ void onPermissionsGranted() {
|
||||
executeRunnable(onPermissionsGranted);
|
||||
executeRunnable(mOnPermissionsGranted);
|
||||
}
|
||||
|
||||
/* package-private */ void onPermissionsDenied() {
|
||||
executeRunnable(onPermissionsDenied);
|
||||
executeRunnable(mOnPermissionsDenied);
|
||||
}
|
||||
|
||||
private void executeRunnable(final Runnable runnable) {
|
||||
|
|
@ -127,13 +127,13 @@ public class PermissionBlock {
|
|||
return;
|
||||
}
|
||||
|
||||
if (onUIThread && onBackgroundThread) {
|
||||
if (mOnUiThread && mOnBackgroundThread) {
|
||||
throw new IllegalStateException("Cannot run callback on more than one thread");
|
||||
}
|
||||
|
||||
if (onUIThread && !ThreadUtils.isOnUiThread()) {
|
||||
if (mOnUiThread && !ThreadUtils.isOnUiThread()) {
|
||||
ThreadUtils.postToUiThread(runnable);
|
||||
} else if (onBackgroundThread && !ThreadUtils.isOnBackgroundThread()) {
|
||||
} else if (mOnBackgroundThread && !ThreadUtils.isOnBackgroundThread()) {
|
||||
ThreadUtils.postToBackgroundThread(runnable);
|
||||
} else {
|
||||
runnable.run();
|
||||
|
|
@ -141,10 +141,10 @@ public class PermissionBlock {
|
|||
}
|
||||
|
||||
/* package-private */ String[] getPermissions() {
|
||||
return permissions;
|
||||
return mPermissions;
|
||||
}
|
||||
|
||||
/* package-private */ boolean hasPermissions(final Context context) {
|
||||
return helper.hasPermissions(context, permissions);
|
||||
return mHelper.hasPermissions(context, mPermissions);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -40,13 +40,13 @@ import android.util.Log;
|
|||
public class MatrixBlobCursor extends AbstractCursor {
|
||||
private static final String LOGTAG = "GeckoMatrixCursor";
|
||||
|
||||
private final String[] columnNames;
|
||||
private final int columnCount;
|
||||
private final String[] mColumnNames;
|
||||
private final int mColumnCount;
|
||||
|
||||
private int rowCount;
|
||||
private Throwable allocationStack;
|
||||
private int mRowCount;
|
||||
private Throwable mAllocationStack;
|
||||
|
||||
Object[] data;
|
||||
Object[] mData;
|
||||
|
||||
/**
|
||||
* Constructs a new cursor with the given initial capacity.
|
||||
|
|
@ -57,16 +57,16 @@ public class MatrixBlobCursor extends AbstractCursor {
|
|||
*/
|
||||
@JNITarget
|
||||
public MatrixBlobCursor(final String[] columnNames, final int initialCapacity) {
|
||||
this.columnNames = columnNames;
|
||||
this.columnCount = columnNames.length;
|
||||
mColumnNames = columnNames;
|
||||
mColumnCount = columnNames.length;
|
||||
|
||||
int capacity = initialCapacity;
|
||||
if (capacity < 1) {
|
||||
capacity = 1;
|
||||
}
|
||||
|
||||
this.data = new Object[columnCount * capacity];
|
||||
this.allocationStack = new Throwable("allocationStack");
|
||||
mData = new Object[mColumnCount * capacity];
|
||||
mAllocationStack = new Throwable("allocationStack");
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -84,8 +84,8 @@ public class MatrixBlobCursor extends AbstractCursor {
|
|||
* Closes the Cursor, releasing all of its resources.
|
||||
*/
|
||||
public void close() {
|
||||
this.allocationStack = null;
|
||||
this.data = null;
|
||||
mAllocationStack = null;
|
||||
mData = null;
|
||||
super.close();
|
||||
}
|
||||
|
||||
|
|
@ -93,17 +93,17 @@ public class MatrixBlobCursor extends AbstractCursor {
|
|||
* Gets value at the given column for the current row.
|
||||
*/
|
||||
protected Object get(final int column) {
|
||||
if (column < 0 || column >= columnCount) {
|
||||
if (column < 0 || column >= mColumnCount) {
|
||||
throw new CursorIndexOutOfBoundsException("Requested column: "
|
||||
+ column + ", # of columns: " + columnCount);
|
||||
+ column + ", # of columns: " + mColumnCount);
|
||||
}
|
||||
if (mPos < 0) {
|
||||
throw new CursorIndexOutOfBoundsException("Before first row.");
|
||||
}
|
||||
if (mPos >= rowCount) {
|
||||
if (mPos >= mRowCount) {
|
||||
throw new CursorIndexOutOfBoundsException("After last row.");
|
||||
}
|
||||
return data[mPos * columnCount + column];
|
||||
return mData[mPos * mColumnCount + column];
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -114,10 +114,10 @@ public class MatrixBlobCursor extends AbstractCursor {
|
|||
* row
|
||||
*/
|
||||
public RowBuilder newRow() {
|
||||
rowCount++;
|
||||
int endIndex = rowCount * columnCount;
|
||||
mRowCount++;
|
||||
int endIndex = mRowCount * mColumnCount;
|
||||
ensureCapacity(endIndex);
|
||||
int start = endIndex - columnCount;
|
||||
int start = endIndex - mColumnCount;
|
||||
return new RowBuilder(start, endIndex);
|
||||
}
|
||||
|
||||
|
|
@ -132,15 +132,15 @@ public class MatrixBlobCursor extends AbstractCursor {
|
|||
*/
|
||||
@JNITarget
|
||||
public void addRow(final Object[] columnValues) {
|
||||
if (columnValues.length != columnCount) {
|
||||
if (columnValues.length != mColumnCount) {
|
||||
throw new IllegalArgumentException("columnNames.length = "
|
||||
+ columnCount + ", columnValues.length = "
|
||||
+ mColumnCount + ", columnValues.length = "
|
||||
+ columnValues.length);
|
||||
}
|
||||
|
||||
int start = rowCount++ * columnCount;
|
||||
ensureCapacity(start + columnCount);
|
||||
System.arraycopy(columnValues, 0, data, start, columnCount);
|
||||
int start = mRowCount++ * mColumnCount;
|
||||
ensureCapacity(start + mColumnCount);
|
||||
System.arraycopy(columnValues, 0, mData, start, mColumnCount);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -154,18 +154,18 @@ public class MatrixBlobCursor extends AbstractCursor {
|
|||
*/
|
||||
@JNITarget
|
||||
public void addRow(final Iterable<?> columnValues) {
|
||||
final int start = rowCount * columnCount;
|
||||
final int start = mRowCount * mColumnCount;
|
||||
|
||||
if (columnValues instanceof ArrayList<?>) {
|
||||
addRow((ArrayList<?>) columnValues, start);
|
||||
return;
|
||||
}
|
||||
|
||||
final int end = start + columnCount;
|
||||
final int end = start + mColumnCount;
|
||||
int current = start;
|
||||
|
||||
ensureCapacity(end);
|
||||
final Object[] localData = data;
|
||||
final Object[] localData = mData;
|
||||
for (Object columnValue : columnValues) {
|
||||
if (current == end) {
|
||||
// TODO: null out row?
|
||||
|
|
@ -182,29 +182,29 @@ public class MatrixBlobCursor extends AbstractCursor {
|
|||
}
|
||||
|
||||
// Increase row count here in case we encounter an exception.
|
||||
rowCount++;
|
||||
mRowCount++;
|
||||
}
|
||||
|
||||
/** Optimization for {@link ArrayList}. */
|
||||
@JNITarget
|
||||
private void addRow(final ArrayList<?> columnValues, final int start) {
|
||||
final int size = columnValues.size();
|
||||
if (size != columnCount) {
|
||||
if (size != mColumnCount) {
|
||||
throw new IllegalArgumentException("columnNames.length = "
|
||||
+ columnCount + ", columnValues.size() = " + size);
|
||||
+ mColumnCount + ", columnValues.size() = " + size);
|
||||
}
|
||||
|
||||
final int end = start + columnCount;
|
||||
final int end = start + mColumnCount;
|
||||
ensureCapacity(end);
|
||||
|
||||
// Take a reference just in case someone calls ensureCapacity
|
||||
// and `data` gets replaced by a new array!
|
||||
final Object[] localData = data;
|
||||
final Object[] localData = mData;
|
||||
for (int i = 0; i < size; i++) {
|
||||
localData[start + i] = columnValues.get(i);
|
||||
}
|
||||
|
||||
rowCount++;
|
||||
mRowCount++;
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -212,13 +212,13 @@ public class MatrixBlobCursor extends AbstractCursor {
|
|||
* a new array, the existing capacity will be at least doubled.
|
||||
*/
|
||||
private void ensureCapacity(final int size) {
|
||||
if (size <= data.length) {
|
||||
if (size <= mData.length) {
|
||||
return;
|
||||
}
|
||||
|
||||
final Object[] oldData = this.data;
|
||||
this.data = new Object[Math.max(size, data.length * 2)];
|
||||
System.arraycopy(oldData, 0, this.data, 0, oldData.length);
|
||||
final Object[] oldData = mData;
|
||||
mData = new Object[Math.max(size, mData.length * 2)];
|
||||
System.arraycopy(oldData, 0, mData, 0, oldData.length);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -229,12 +229,12 @@ public class MatrixBlobCursor extends AbstractCursor {
|
|||
* Not thread-safe.
|
||||
*/
|
||||
public class RowBuilder {
|
||||
private int index;
|
||||
private final int endIndex;
|
||||
private int mIndex;
|
||||
private final int mEndIndex;
|
||||
|
||||
RowBuilder(final int index, final int endIndex) {
|
||||
this.index = index;
|
||||
this.endIndex = endIndex;
|
||||
this.mIndex = index;
|
||||
this.mEndIndex = endIndex;
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -245,11 +245,11 @@ public class MatrixBlobCursor extends AbstractCursor {
|
|||
* @return this builder to support chaining
|
||||
*/
|
||||
public RowBuilder add(final Object columnValue) {
|
||||
if (index == endIndex) {
|
||||
if (mIndex == mEndIndex) {
|
||||
throw new CursorIndexOutOfBoundsException("No more columns left.");
|
||||
}
|
||||
|
||||
data[index++] = columnValue;
|
||||
mData[mIndex++] = columnValue;
|
||||
return this;
|
||||
}
|
||||
}
|
||||
|
|
@ -258,28 +258,28 @@ public class MatrixBlobCursor extends AbstractCursor {
|
|||
* Not thread safe.
|
||||
*/
|
||||
public void set(final int column, final Object value) {
|
||||
if (column < 0 || column >= columnCount) {
|
||||
if (column < 0 || column >= mColumnCount) {
|
||||
throw new CursorIndexOutOfBoundsException("Requested column: "
|
||||
+ column + ", # of columns: " + columnCount);
|
||||
+ column + ", # of columns: " + mColumnCount);
|
||||
}
|
||||
if (mPos < 0) {
|
||||
throw new CursorIndexOutOfBoundsException("Before first row.");
|
||||
}
|
||||
if (mPos >= rowCount) {
|
||||
if (mPos >= mRowCount) {
|
||||
throw new CursorIndexOutOfBoundsException("After last row.");
|
||||
}
|
||||
data[mPos * columnCount + column] = value;
|
||||
mData[mPos * mColumnCount + column] = value;
|
||||
}
|
||||
|
||||
// AbstractCursor implementation.
|
||||
@Override
|
||||
public int getCount() {
|
||||
return rowCount;
|
||||
return mRowCount;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String[] getColumnNames() {
|
||||
return columnNames;
|
||||
return mColumnNames;
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
@ -354,7 +354,7 @@ public class MatrixBlobCursor extends AbstractCursor {
|
|||
@Override
|
||||
protected void finalize() {
|
||||
if (!isClosed()) {
|
||||
Log.e(LOGTAG, "Cursor finalized without being closed", this.allocationStack);
|
||||
Log.e(LOGTAG, "Cursor finalized without being closed", mAllocationStack);
|
||||
}
|
||||
|
||||
super.finalize();
|
||||
|
|
|
|||
|
|
@ -18,11 +18,11 @@ final class GeckoBackgroundThread extends Thread {
|
|||
|
||||
// The initial Runnable to run on the new thread. Its purpose
|
||||
// is to avoid us having to wait for the new thread to start.
|
||||
private Runnable initialRunnable;
|
||||
private Runnable mInitialRunnable;
|
||||
|
||||
// Singleton, so private constructor.
|
||||
private GeckoBackgroundThread(final Runnable initialRunnable) {
|
||||
this.initialRunnable = initialRunnable;
|
||||
mInitialRunnable = initialRunnable;
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
@ -35,9 +35,9 @@ final class GeckoBackgroundThread extends Thread {
|
|||
GeckoBackgroundThread.class.notifyAll();
|
||||
}
|
||||
|
||||
if (initialRunnable != null) {
|
||||
initialRunnable.run();
|
||||
initialRunnable = null;
|
||||
if (mInitialRunnable != null) {
|
||||
mInitialRunnable.run();
|
||||
mInitialRunnable = null;
|
||||
}
|
||||
|
||||
Looper.loop();
|
||||
|
|
|
|||
|
|
@ -28,27 +28,27 @@ public class IOUtils {
|
|||
public static class ConsumedInputStream {
|
||||
public final int consumedLength;
|
||||
// Only reassigned in getTruncatedData.
|
||||
private byte[] consumedData;
|
||||
private byte[] mConsumedData;
|
||||
|
||||
public ConsumedInputStream(final int consumedLength, final byte[] consumedData) {
|
||||
this.consumedLength = consumedLength;
|
||||
this.consumedData = consumedData;
|
||||
this.mConsumedData = consumedData;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the data trimmed to the length of the actual payload read, caching the result.
|
||||
*/
|
||||
public byte[] getTruncatedData() {
|
||||
if (consumedData.length == consumedLength) {
|
||||
return consumedData;
|
||||
if (mConsumedData.length == consumedLength) {
|
||||
return mConsumedData;
|
||||
}
|
||||
|
||||
consumedData = truncateBytes(consumedData, consumedLength);
|
||||
return consumedData;
|
||||
mConsumedData = truncateBytes(mConsumedData, consumedLength);
|
||||
return mConsumedData;
|
||||
}
|
||||
|
||||
public byte[] getData() {
|
||||
return consumedData;
|
||||
return mConsumedData;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -15,30 +15,30 @@ import java.util.concurrent.ConcurrentHashMap;
|
|||
* Alas, LruCache is final, so we compose rather than inherit.
|
||||
*/
|
||||
public class NonEvictingLruCache<K, V> {
|
||||
private final ConcurrentHashMap<K, V> permanent = new ConcurrentHashMap<K, V>();
|
||||
private final LruCache<K, V> evictable;
|
||||
private final ConcurrentHashMap<K, V> mPermanent = new ConcurrentHashMap<K, V>();
|
||||
private final LruCache<K, V> mEvitable;
|
||||
|
||||
public NonEvictingLruCache(final int evictableSize) {
|
||||
evictable = new LruCache<K, V>(evictableSize);
|
||||
mEvitable = new LruCache<K, V>(evictableSize);
|
||||
}
|
||||
|
||||
public V get(final K key) {
|
||||
V val = permanent.get(key);
|
||||
V val = mPermanent.get(key);
|
||||
if (val == null) {
|
||||
return evictable.get(key);
|
||||
return mEvitable.get(key);
|
||||
}
|
||||
return val;
|
||||
}
|
||||
|
||||
public void putWithoutEviction(final K key, final V value) {
|
||||
permanent.put(key, value);
|
||||
mPermanent.put(key, value);
|
||||
}
|
||||
|
||||
public void put(final K key, final V value) {
|
||||
evictable.put(key, value);
|
||||
mEvitable.put(key, value);
|
||||
}
|
||||
|
||||
public void evictAll() {
|
||||
evictable.evictAll();
|
||||
mEvitable.evictAll();
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -20,10 +20,10 @@ import org.mozilla.gecko.util.ThreadUtils;
|
|||
* {@link #surfaceChanged(Surface, int, int, int, int)} is called and before {@link #surfaceDestroyed()} returns.
|
||||
*/
|
||||
public class GeckoDisplay {
|
||||
private final GeckoSession session;
|
||||
private final GeckoSession mSession;
|
||||
|
||||
protected GeckoDisplay(final GeckoSession session) {
|
||||
this.session = session;
|
||||
mSession = session;
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -66,8 +66,8 @@ public class GeckoDisplay {
|
|||
throw new IllegalArgumentException("Parameters can not be negative.");
|
||||
}
|
||||
|
||||
if (session.getDisplay() == this) {
|
||||
session.onSurfaceChanged(surface, left, top, width, height);
|
||||
if (mSession.getDisplay() == this) {
|
||||
mSession.onSurfaceChanged(surface, left, top, width, height);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -82,8 +82,8 @@ public class GeckoDisplay {
|
|||
public void surfaceDestroyed() {
|
||||
ThreadUtils.assertOnUiThread();
|
||||
|
||||
if (session.getDisplay() == this) {
|
||||
session.onSurfaceDestroyed();
|
||||
if (mSession.getDisplay() == this) {
|
||||
mSession.onSurfaceDestroyed();
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -100,8 +100,8 @@ public class GeckoDisplay {
|
|||
public void screenOriginChanged(final int left, final int top) {
|
||||
ThreadUtils.assertOnUiThread();
|
||||
|
||||
if (session.getDisplay() == this) {
|
||||
session.onScreenOriginChanged(left, top);
|
||||
if (mSession.getDisplay() == this) {
|
||||
mSession.onScreenOriginChanged(left, top);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -118,7 +118,7 @@ public class GeckoDisplay {
|
|||
@UiThread
|
||||
public boolean shouldPinOnScreen() {
|
||||
ThreadUtils.assertOnUiThread();
|
||||
return session.getDisplay() == this && session.shouldPinOnScreen();
|
||||
return mSession.getDisplay() == this && mSession.shouldPinOnScreen();
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -139,12 +139,12 @@ public class GeckoDisplay {
|
|||
@UiThread
|
||||
public @NonNull GeckoResult<Bitmap> capturePixels() {
|
||||
ThreadUtils.assertOnUiThread();
|
||||
if (!session.isCompositorReady()) {
|
||||
if (!mSession.isCompositorReady()) {
|
||||
return GeckoResult.fromException(
|
||||
new IllegalStateException("Compositor must be ready before pixels can be captured"));
|
||||
}
|
||||
GeckoResult<Bitmap> result = new GeckoResult<>();
|
||||
session.mCompositor.requestScreenPixels(result);
|
||||
mSession.mCompositor.requestScreenPixels(result);
|
||||
return result;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Загрузка…
Ссылка в новой задаче