Initial implementation of FeedStreamSurface

This is the bridge class that lets Android code access native
code for feed related functionalities.

Bug: 1044139
Change-Id: I59b5857c81b6fb256d6db74db3b4f8860b926fca
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2127729Reviewed-by: Dan H <harringtond@chromium.org>
Reviewed-by: Andrew Grieve <agrieve@chromium.org>
Commit-Queue: Jian Li <jianli@chromium.org>
Cr-Commit-Position: refs/heads/master@{#754951}

chrome/android/BUILD.gn

@@ -339,6 +339,7 @@ android_library("chrome_java") {
     "//components/external_intents/android:java",
     "//components/feature_engagement:feature_engagement_java",
     "//components/feed/core/proto:proto_java",
+    "//components/feed/core/proto:proto_java_v2",
     "//components/find_in_page/android:java",
     "//components/gcm_driver/android:gcm_driver_java",
     "//components/gcm_driver/instance_id/android:instance_id_driver_java",
@@ -2978,6 +2979,7 @@ generate_jni("chrome_jni_headers") {
       "feed/core/java/src/org/chromium/chrome/browser/feed/FeedOfflineBridge.java",
       "feed/core/java/src/org/chromium/chrome/browser/feed/FeedSchedulerBridge.java",
       "feed/core/java/src/org/chromium/chrome/browser/feed/v2/FeedServiceBridge.java",
+      "feed/core/java/src/org/chromium/chrome/browser/feed/v2/FeedStreamSurface.java",
     ]
   }
 

chrome/android/feed/core/java/src/org/chromium/chrome/browser/feed/v2/FeedStreamSurface.java

+// Copyright 2020 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.chrome.browser.feed.v2;
+
+import org.chromium.base.annotations.CalledByNative;
+import org.chromium.base.annotations.JNINamespace;
+import org.chromium.base.annotations.NativeMethods;
+import org.chromium.components.feed.proto.FeedUiProto.StreamUpdate;
+
+import java.util.List;
+
+/**
+ * Bridge class that lets Android code access native code for feed related functionalities.
+ *
+ * Created once for each StreamSurfaceMediator corresponding to each NTP/start surface.
+ */
+@JNINamespace("feed")
+public class FeedStreamSurface {
+    private final long mNativeFeedStreamSurface;
+
+    /**
+     * Creates a {@link FeedStreamSurface} for creating native side bridge to access native feed
+     * client implementation.
+     */
+    public FeedStreamSurface() {
+        mNativeFeedStreamSurface = FeedStreamSurfaceJni.get().init(FeedStreamSurface.this);
+    }
+
+    /**
+     * Called when the stream update content is available. The content will get passed to UI
+     */
+    @CalledByNative
+    void onStreamUpdated(byte[] data) {
+        try {
+            StreamUpdate streamUpdate = StreamUpdate.parseFrom(data);
+        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+            // Consume exception for now, ignoring unparsable events.
+        }
+    }
+
+    /**
+     * Informs that a particular URL is being navigated to.
+     */
+    public void navigationDone(String url, boolean inNewTab) {
+        FeedStreamSurfaceJni.get().navigationDone(
+                mNativeFeedStreamSurface, FeedStreamSurface.this, url, inNewTab);
+    }
+
+    /**
+     * Requests additional content to be loaded. Once the load is completed, onStreamUpdated will be
+     * called.
+     */
+    public void loadMore() {
+        FeedStreamSurfaceJni.get().loadMore(mNativeFeedStreamSurface, FeedStreamSurface.this);
+    }
+
+    /**
+     * Handles uploading data for ThereAndBackAgain.
+     */
+    public void processThereAndBackAgain(byte[] data) {
+        FeedStreamSurfaceJni.get().processThereAndBackAgain(
+                mNativeFeedStreamSurface, FeedStreamSurface.this, data);
+    }
+
+    /**
+     * Executes an ephemeral change, i.e. dismissals, that is described by a list of data operations
+     * serialized as bytes. A change ID will be returned and it can be used to commit or discard the
+     * change. If the change ID is 0, it means failure.
+     */
+    public int executeEphemeralChange(List<byte[]> serializedDataOperations) {
+        return FeedStreamSurfaceJni.get().executeEphemeralChange(
+                mNativeFeedStreamSurface, FeedStreamSurface.this, serializedDataOperations);
+    }
+
+    /**
+     * Commits a previously executed ephemeral change.
+     */
+    public void commitEphemeralChange(int changeId) {
+        FeedStreamSurfaceJni.get().commitEphemeralChange(
+                mNativeFeedStreamSurface, FeedStreamSurface.this, changeId);
+    }
+
+    /**
+     * Discards a previously executed ephemeral change.
+     */
+    public void discardEphemeralChange(int changeId) {
+        FeedStreamSurfaceJni.get().discardEphemeralChange(
+                mNativeFeedStreamSurface, FeedStreamSurface.this, changeId);
+    }
+
+    /**
+     * Informs that the surface is opened. We can request the initial set of content now. Once
+     * the content is available, onStreamUpdated will be called.
+     */
+    public void surfaceOpened() {
+        FeedStreamSurfaceJni.get().surfaceOpened(mNativeFeedStreamSurface, FeedStreamSurface.this);
+    }
+
+    /**
+     * Informs that the surface is closed. Any cleanup can be performed now.
+     */
+    public void surfaceClosed() {
+        FeedStreamSurfaceJni.get().surfaceClosed(mNativeFeedStreamSurface, FeedStreamSurface.this);
+    }
+
+    @NativeMethods
+    interface Natives {
+        long init(FeedStreamSurface caller);
+        void navigationDone(long nativeFeedStreamSurface, FeedStreamSurface caller, String url,
+                boolean inNewTab);
+        void loadMore(long nativeFeedStreamSurface, FeedStreamSurface caller);
+        void processThereAndBackAgain(
+                long nativeFeedStreamSurface, FeedStreamSurface caller, byte[] data);
+        int executeEphemeralChange(long nativeFeedStreamSurface, FeedStreamSurface caller,
+                List<byte[]> serializedDataOperations);
+        void commitEphemeralChange(
+                long nativeFeedStreamSurface, FeedStreamSurface caller, int changeId);
+        void discardEphemeralChange(
+                long nativeFeedStreamSurface, FeedStreamSurface caller, int changeId);
+        void surfaceOpened(long nativeFeedStreamSurface, FeedStreamSurface caller);
+        void surfaceClosed(long nativeFeedStreamSurface, FeedStreamSurface caller);
+    }
+}

chrome/android/feed/feed_java_sources.gni

@@ -379,6 +379,7 @@ if (enable_feed_in_chrome) {
     "//chrome/android/feed/core/java/src/org/chromium/chrome/browser/feed/tooltip/BasicTooltipSupportedApi.java",
     "//chrome/android/feed/core/java/src/org/chromium/chrome/browser/feed/tooltip/FeedTooltipUtils.java",
     "//chrome/android/feed/core/java/src/org/chromium/chrome/browser/feed/v2/FeedServiceBridge.java",
+    "//chrome/android/feed/core/java/src/org/chromium/chrome/browser/feed/v2/FeedStreamSurface.java",
   ]
 
   feed_srcjar_deps = [ "//components/feed/core:feed_core_java_enums_srcjar" ]

chrome/browser/BUILD.gn

@@ -4903,6 +4903,8 @@ jumbo_static_library("browser") {
       "android/feed/v2/feed_service_bridge.h",
       "android/feed/v2/feed_service_factory.cc",
       "android/feed/v2/feed_service_factory.h",
+      "android/feed/v2/feed_stream_surface.cc",
+      "android/feed/v2/feed_stream_surface.h",
     ]
     deps += [
       "//components/feed/content:feed_content",

chrome/browser/android/feed/v2/feed_stream_surface.cc

+// Copyright 2020 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.
+
+#include "chrome/browser/android/feed/v2/feed_stream_surface.h"
+
+#include "base/android/jni_android.h"
+#include "base/android/jni_array.h"
+#include "chrome/android/chrome_jni_headers/FeedStreamSurface_jni.h"
+#include "components/feed/core/proto/v2/ui.pb.h"
+
+using base::android::JavaParamRef;
+using base::android::JavaRef;
+using base::android::ScopedJavaLocalRef;
+using base::android::ToJavaByteArray;
+
+namespace feed {
+
+static jlong JNI_FeedStreamSurface_Init(JNIEnv* env,
+                                        const JavaParamRef<jobject>& j_this) {
+  return reinterpret_cast<intptr_t>(new FeedStreamSurface(j_this));
+}
+
+FeedStreamSurface::FeedStreamSurface(const JavaRef<jobject>& j_this) {
+  java_ref_.Reset(j_this);
+}
+
+FeedStreamSurface::~FeedStreamSurface() {}
+
+void FeedStreamSurface::OnStreamUpdated(
+    const feedui::StreamUpdate& stream_update) {
+  JNIEnv* env = base::android::AttachCurrentThread();
+  int32_t data_size = stream_update.ByteSize();
+  std::vector<uint8_t> data;
+  data.resize(data_size);
+  stream_update.SerializeToArray(data.data(), data_size);
+  ScopedJavaLocalRef<jbyteArray> j_data =
+      ToJavaByteArray(env, data.data(), data_size);
+  Java_FeedStreamSurface_onStreamUpdated(env, java_ref_, j_data);
+}
+
+void FeedStreamSurface::NavigationDone(JNIEnv* env,
+                                       const JavaParamRef<jobject>& obj,
+                                       const JavaParamRef<jstring>& url,
+                                       jboolean in_new_tab) {}
+
+void FeedStreamSurface::LoadMore(JNIEnv* env,
+                                 const JavaParamRef<jobject>& obj) {}
+
+void FeedStreamSurface::ProcessThereAndBackAgain(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& obj,
+    const JavaParamRef<jbyteArray>& data) {}
+
+int FeedStreamSurface::ExecuteEphemeralChange(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& obj,
+    const JavaParamRef<jobject>& data) {
+  return 0;
+}
+
+void FeedStreamSurface::CommitEphemeralChange(JNIEnv* env,
+                                              const JavaParamRef<jobject>& obj,
+                                              int change_id) {}
+
+void FeedStreamSurface::DiscardEphemeralChange(JNIEnv* env,
+                                               const JavaParamRef<jobject>& obj,
+                                               int change_id) {}
+
+void FeedStreamSurface::SurfaceOpened(JNIEnv* env,
+                                      const JavaParamRef<jobject>& obj) {}
+
+void FeedStreamSurface::SurfaceClosed(JNIEnv* env,
+                                      const JavaParamRef<jobject>& obj) {}
+
+}  // namespace feed

chrome/browser/android/feed/v2/feed_stream_surface.h

+// Copyright 2020 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.
+
+#ifndef CHROME_BROWSER_ANDROID_FEED_V2_FEED_STREAM_SURFACE_H_
+#define CHROME_BROWSER_ANDROID_FEED_V2_FEED_STREAM_SURFACE_H_
+
+#include "base/android/jni_android.h"
+#include "base/android/scoped_java_ref.h"
+#include "base/macros.h"
+
+namespace feedui {
+class StreamUpdate;
+}
+
+namespace feed {
+
+// Native access to |FeedStreamSurface| in Java.
+// Created once for each NTP/start surface.
+class FeedStreamSurface {
+ public:
+  explicit FeedStreamSurface(const base::android::JavaRef<jobject>& j_this);
+  ~FeedStreamSurface();
+
+  void OnStreamUpdated(const feedui::StreamUpdate& stream_update);
+
+  void NavigationDone(JNIEnv* env,
+                      const base::android::JavaParamRef<jobject>& caller,
+                      const base::android::JavaParamRef<jstring>& url,
+                      jboolean in_new_tab);
+
+  void LoadMore(JNIEnv* env,
+                const base::android::JavaParamRef<jobject>& caller);
+
+  void ProcessThereAndBackAgain(
+      JNIEnv* env,
+      const base::android::JavaParamRef<jobject>& obj,
+      const base::android::JavaParamRef<jbyteArray>& data);
+
+  int ExecuteEphemeralChange(JNIEnv* env,
+                             const base::android::JavaParamRef<jobject>& caller,
+                             const base::android::JavaParamRef<jobject>& data);
+
+  void CommitEphemeralChange(JNIEnv* env,
+                             const base::android::JavaParamRef<jobject>& caller,
+                             int change_id);
+
+  void DiscardEphemeralChange(
+      JNIEnv* env,
+      const base::android::JavaParamRef<jobject>& caller,
+      int change_id);
+
+  void SurfaceOpened(JNIEnv* env,
+                     const base::android::JavaParamRef<jobject>& caller);
+
+  void SurfaceClosed(JNIEnv* env,
+                     const base::android::JavaParamRef<jobject>& caller);
+
+ private:
+  base::android::ScopedJavaGlobalRef<jobject> java_ref_;
+
+  DISALLOW_COPY_AND_ASSIGN(FeedStreamSurface);
+};
+
+}  // namespace feed
+
+#endif  // CHROME_BROWSER_ANDROID_FEED_V2_FEED_STREAM_SURFACE_H_

components/feed/core/proto/BUILD.gn

@@ -113,4 +113,9 @@ if (is_android) {
       "wire/version.proto",
     ]
   }
+
+  proto_java_library("proto_java_v2") {
+    proto_path = "../../../../"
+    sources = [ "v2/ui.proto" ]
+  }
 }

components/feed/core/proto/v2/ui.proto

@@ -8,6 +8,9 @@ package feedui;
 
 option optimize_for = LITE_RUNTIME;
 
+option java_package = "org.chromium.components.feed.proto";
+option java_outer_classname = "FeedUiProto";
+
 // This is a simplified and complete set of protos that define UI.
 // It includes everything from search.now.ui needed in the UI, and excludes
 // other data to reduce complexity. These proto messages should be constructible