Android: Remove GetApplicationContext part 4

media/midi/java/src/org/chromium/midi/UsbMidiDeviceFactoryAndroid.java

 // Copyright 2014 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.midi;
 
 import android.app.PendingIntent;
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.hardware.usb.UsbConstants;
 import android.hardware.usb.UsbDevice;
 import android.hardware.usb.UsbInterface;
 import android.hardware.usb.UsbManager;
 import android.os.Parcelable;
 
+import org.chromium.base.ContextUtils;
 import org.chromium.base.annotations.CalledByNative;
 import org.chromium.base.annotations.JNINamespace;
 
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 /**
@@ skipping 29 matching lines @@
 
     /**
      * The identifier of this factory.
      */
     private long mNativePointer;
 
     private static final String ACTION_USB_PERMISSION = "org.chromium.midi.USB_PERMISSION";
 
     /**
      * Constructs a UsbMidiDeviceAndroid.
-     * @param context
      * @param nativePointer The native pointer to which the created factory is associated.
      */
-    UsbMidiDeviceFactoryAndroid(Context context, long nativePointer) {
-        mUsbManager = (UsbManager) context.getSystemService(Context.USB_SERVICE);
+    UsbMidiDeviceFactoryAndroid(long nativePointer) {
+        mUsbManager = (UsbManager) ContextUtils.getApplicationContext().getSystemService(
+                Context.USB_SERVICE);
         mNativePointer = nativePointer;
         mReceiver = new BroadcastReceiver() {
             @Override
             public void onReceive(Context context, Intent intent) {
                 Parcelable extra = intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);
                 if (UsbManager.ACTION_USB_DEVICE_ATTACHED.equals(intent.getAction())) {
-                    requestDevicePermissionIfNecessary(context, (UsbDevice) extra);
+                    requestDevicePermissionIfNecessary((UsbDevice) extra);
                 }
                 if (UsbManager.ACTION_USB_DEVICE_DETACHED.equals(intent.getAction())) {
                     onUsbDeviceDetached((UsbDevice) extra);
                 }
                 if (ACTION_USB_PERMISSION.equals(intent.getAction())) {
                     onUsbDevicePermissionRequestDone(context, intent);
                 }
             }
         };
         IntentFilter filter = new IntentFilter();
         filter.addAction(UsbManager.ACTION_USB_DEVICE_ATTACHED);
         filter.addAction(UsbManager.ACTION_USB_DEVICE_DETACHED);
         filter.addAction(ACTION_USB_PERMISSION);
-        context.registerReceiver(mReceiver, filter);
+        ContextUtils.getApplicationContext().registerReceiver(mReceiver, filter);
         mRequestedDevices = new HashSet<UsbDevice>();
     }
 
     /**
      * Constructs a UsbMidiDeviceAndroid.
-     * @param context
      * @param nativePointer The native pointer to which the created factory is associated.
      */
     @CalledByNative
-    static UsbMidiDeviceFactoryAndroid create(Context context, long nativePointer) {
-        return new UsbMidiDeviceFactoryAndroid(context, nativePointer);
+    static UsbMidiDeviceFactoryAndroid create(long nativePointer) {
+        return new UsbMidiDeviceFactoryAndroid(nativePointer);
     }
 
     /**
      * Enumerates USB-MIDI devices.
      * If there are devices having USB-MIDI interfaces, this function requests permission for
      * accessing the device to the user.
      * When the permission request is accepted or rejected,  nativeOnUsbMidiDeviceRequestDone
      * will be called.
      *
      * If there are no USB-MIDI interfaces, this function returns false.
-     * @param context
      * @return true if some permission requests are in progress.
      */
     @CalledByNative
-    boolean enumerateDevices(Context context) {
+    boolean enumerateDevices() {
         assert !mIsEnumeratingDevices;
         mIsEnumeratingDevices = true;
         Map<String, UsbDevice> devices = mUsbManager.getDeviceList();
         if (devices.isEmpty()) {
             // No USB-MIDI devices are found.
             mIsEnumeratingDevices = false;
             return false;
         }
         for (UsbDevice device : devices.values()) {
-            requestDevicePermissionIfNecessary(context, device);
+            requestDevicePermissionIfNecessary(device);
         }
         return !mRequestedDevices.isEmpty();
     }
 
     /**
      * Request a device access permission if there is a MIDI interface in the device.
      *
-     * @param context
      * @param device a USB device
      */
-    private void requestDevicePermissionIfNecessary(Context context, UsbDevice device) {
+    private void requestDevicePermissionIfNecessary(UsbDevice device) {
         for (UsbDevice d : mRequestedDevices) {
             if (d.getDeviceId() == device.getDeviceId()) {
                 // It is already requested.
                 return;
             }
         }
 
         for (int i = 0; i < device.getInterfaceCount(); ++i) {
             UsbInterface iface = device.getInterface(i);
             if (iface.getInterfaceClass() == UsbConstants.USB_CLASS_AUDIO
                     && iface.getInterfaceSubclass() == UsbMidiDeviceAndroid.MIDI_SUBCLASS) {
                 // There is at least one interface supporting MIDI.
-                mUsbManager.requestPermission(
-                        device, PendingIntent.getBroadcast(
-                                        context, 0, new Intent(ACTION_USB_PERMISSION), 0));
+                mUsbManager.requestPermission(device,
+                        PendingIntent.getBroadcast(ContextUtils.getApplicationContext(), 0,
+                                new Intent(ACTION_USB_PERMISSION), 0));
                 mRequestedDevices.add(device);
                 break;
             }
         }
     }
 
     /**
      * Called when a USB device is detached.
      *
      * @param device a USB device
@@ skipping 75 matching lines @@
         if (mIsEnumeratingDevices) {
             nativeOnUsbMidiDeviceRequestDone(mNativePointer, mDevices.toArray());
             mIsEnumeratingDevices = false;
         } else if (midiDevice != null) {
             nativeOnUsbMidiDeviceAttached(mNativePointer, midiDevice);
         }
     }
 
     /**
      * Disconnects the native object.
-     * @param context
      */
     @CalledByNative
-    void close(Context context) {
+    void close() {
         mNativePointer = 0;
-        context.unregisterReceiver(mReceiver);
+        ContextUtils.getApplicationContext().unregisterReceiver(mReceiver);
     }
 
     private static native void nativeOnUsbMidiDeviceRequestDone(
             long nativeUsbMidiDeviceFactoryAndroid, Object[] devices);
     private static native void nativeOnUsbMidiDeviceAttached(
             long nativeUsbMidiDeviceFactoryAndroid, Object device);
     private static native void nativeOnUsbMidiDeviceDetached(
             long nativeUsbMidiDeviceFactoryAndroid, int index);
 }