[webnfc] Implement push method for Android nfc mojo service.

content/public/android/java/src/org/chromium/content/browser/ServiceRegistrar.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.content.browser;
 
+import android.app.Activity;
 import android.content.Context;
+import android.support.annotation.Nullable;
 
 import org.chromium.base.annotations.CalledByNative;
 import org.chromium.base.annotations.JNINamespace;
 import org.chromium.content.browser.ServiceRegistry.ImplementationFactory;
+import org.chromium.content_public.browser.WebContents;
 import org.chromium.device.battery.BatteryMonitorFactory;
+import org.chromium.device.nfc.NfcImpl;
 import org.chromium.device.vibration.VibrationManagerImpl;
 import org.chromium.mojom.device.BatteryMonitor;
 import org.chromium.mojom.device.VibrationManager;
+import org.chromium.mojom.device.nfc.Nfc;
+
+import java.util.concurrent.Callable;
 
 /**
  * Registers mojo services exposed by the browser in the given registry.
  */
 @JNINamespace("content")
 class ServiceRegistrar {
     // BatteryMonitorFactory can't implement ImplementationFactory itself, as we don't depend on
     // /content in /device. Hence we use BatteryMonitorImplementationFactory as a wrapper.
     private static class BatteryMonitorImplementationFactory
             implements ImplementationFactory<BatteryMonitor> {
         private final BatteryMonitorFactory mFactory;
 
         BatteryMonitorImplementationFactory(Context applicationContext) {
             mFactory = new BatteryMonitorFactory(applicationContext);
         }
 
         @Override
         public BatteryMonitor createImpl() {
             return mFactory.createMonitor();
         }
     }
 
+    private static class NfcImplementationFactory implements ImplementationFactory<Nfc> {
+        private final Context mContext;
+        private final WebContents mContents;
+
+        NfcImplementationFactory(Context context, WebContents contents) {
+            mContext = context;
+            mContents = contents;
+        }
+
+        @Nullable
+        private Activity getActivity() {
+            Activity activity = null;
+            ContentViewCore viewCore = null;
+            if (mContents != null) {
+                viewCore = ContentViewCore.fromWebContents(mContents);
+            }
+
+            if (viewCore != null && viewCore.getWindowAndroid() != null) {
+                activity = viewCore.getWindowAndroid().getActivity().get();
+            }
+
+            return activity;
+        }
+
+        @Override
+        public Nfc createImpl() {
+            return new NfcImpl(mContext, new Callable<Activity>() {

[Ted C, 2016/05/13 22:04:08]

to avoid the awkward layering, maybe we can put the window provider logic here
(letting the new interfaces live in ui/ for now)?

Ideally, I'd like to avoid having to put the WindowAndroidProvider in device/
because I feel that will quickly not be sufficient as other non-content packages
need it.  So for now, maybe we still add the provider and make ContentViewCore
implement it, but we then build out the dependency here.

Instead of the NfcImpl registering for changes to the window android, the
factory would and it would push the changes to the impl.  Granted, then the
factory would need to track the created Nfc instance, which really doesn't fit
well with the factory pattern.

I guess we could have a shim class that extends NfcImpl here? 
ContextAwareNfcImpl or something that registers for the observer in the
constructor and removes the observer in close()

private static class ContextAwareNfcImpl extends NfcImpl implements
OnWindowAndroidChangedObserver {
    ContextAwareNfcImpl(Context context, ContentViewCore cvc) {
        super(context);
        cvc.addOnWindowAndroidChangedObserver(this);
        setActivity(....);
    }

    @Override
    public void close() {
        super.close();
        mCvc.removeOnWindowAndroidChangedObserver(this);
    }

    @Override
    onWindowAndroidChanged(...) {
        setActivity(getActivityFromNewWindowAndroid-yMethod);
    }
}

Then you expose just setActivity in the base class and you can update it from
here.  Thoughts?  The factory wouldn't need to know about it and it is
"somewhat" not too ugly.

[shalamov, 2016/05/17 12:30:32]

Done.

+                public Activity call() {
+                    return getActivity();
+                }
+            });
+        }
+    }
+
     private static class VibrationManagerImplementationFactory
             implements ImplementationFactory<VibrationManager> {
         private final Context mApplicationContext;
 
         VibrationManagerImplementationFactory(Context applicationContext) {
             mApplicationContext = applicationContext;
         }
 
         @Override
         public VibrationManager createImpl() {
             return new VibrationManagerImpl(mApplicationContext);
         }
     }
 
     @CalledByNative
     static void registerProcessHostServices(ServiceRegistry registry, Context applicationContext) {
         assert applicationContext != null;
         registry.addService(BatteryMonitor.MANAGER,
                 new BatteryMonitorImplementationFactory(applicationContext));
         registry.addService(VibrationManager.MANAGER,
                 new VibrationManagerImplementationFactory(applicationContext));
     }
 
     @CalledByNative
-    static void registerFrameHostServices(ServiceRegistry registry, Context applicationContext) {
+    static void registerFrameHostServices(ServiceRegistry registry,
+            Context applicationContext, WebContents contents) {
         assert applicationContext != null;
         // TODO(avayvod): Register the PresentationService implementation here.
+        registry.addService(Nfc.MANAGER,
+                new NfcImplementationFactory(applicationContext, contents));
     }
 }