Introduce ViewRoot to forward input/view events to native

ui/android/view_android.cc

 // Copyright 2016 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 "ui/android/view_android.h"
 
 #include <algorithm>
 
 #include "base/android/jni_android.h"
 #include "cc/layers/layer.h"
 #include "jni/ViewAndroidDelegate_jni.h"
+#include "ui/android/event_handler.h"
+#include "ui/android/view_client.h"
 #include "ui/android/window_android.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 
 namespace ui {
 
+using base::android::JavaParamRef;
 using base::android::JavaRef;
 using base::android::ScopedJavaLocalRef;
 
 ViewAndroid::ScopedAnchorView::ScopedAnchorView(
     JNIEnv* env,
     const JavaRef<jobject>& jview,
     const JavaRef<jobject>& jdelegate)
     : view_(env, jview.obj()), delegate_(env, jdelegate.obj()) {
   // If there's a view, then we need a delegate to remove it.
   DCHECK(!jdelegate.is_null() || jview.is_null());
@@ skipping 33 matching lines @@
   view_.reset();
   delegate_.reset();
 }
 
 const base::android::ScopedJavaLocalRef<jobject>
 ViewAndroid::ScopedAnchorView::view() const {
   JNIEnv* env = base::android::AttachCurrentThread();
   return view_.get(env);
 }
 
-ViewAndroid::ViewAndroid(const JavaRef<jobject>& delegate)
-    : parent_(nullptr)
-    , delegate_(base::android::AttachCurrentThread(),
-                delegate.obj()) {}
-
-ViewAndroid::ViewAndroid() : parent_(nullptr) {}
+ViewAndroid::ViewAndroid(ViewClient* client) : parent_(nullptr),

[boliu, 2016/12/08 05:01:06]

fwiw, inline init for member variable with static initial values is encouraged
now, so you could put "parent_ = nullptr;" in the header if you want, same with
width/height

but this is fine too

[Jinsuk Kim, 2016/12/13 23:20:38]

Acknowledged.

+                                               client_(client),
+                                               physical_width_pix_(0),
+                                               physical_height_pix_(0) {}
+ViewAndroid::ViewAndroid() : ViewAndroid(nullptr) {}
 
 ViewAndroid::~ViewAndroid() {
   RemoveFromParent();
 
-  for (std::list<ViewAndroid*>::iterator it = children_.begin();
-       it != children_.end(); it++) {
-    DCHECK_EQ((*it)->parent_, this);
-    (*it)->parent_ = nullptr;
+  for (auto& child : children_) {
+    DCHECK_EQ(child->parent_, this);
+    child->parent_ = nullptr;
   }
+
+  JNIEnv* env = base::android::AttachCurrentThread();
+  const ScopedJavaLocalRef<jobject> handler = event_handler_.get(env);
+  if (!handler.is_null())
+    OnDestroyNativeView(env, handler);
 }
 
 void ViewAndroid::SetDelegate(const JavaRef<jobject>& delegate) {
+  // A ViewAndroid may have its own delegate or otherwise will
+  // use the next available parent's delegate.
   JNIEnv* env = base::android::AttachCurrentThread();
   delegate_ = JavaObjectWeakGlobalRef(env, delegate);
 }
 
 void ViewAndroid::AddChild(ViewAndroid* child) {
   DCHECK(child);
   DCHECK(std::find(children_.begin(), children_.end(), child) ==
          children_.end());
+  DCHECK(!HasEventHandlerInTreeHierarchy() ||
+         !child->HasEventHandlerInSubtree());
 
   children_.push_back(child);
   if (child->parent_)
     child->RemoveFromParent();
   child->parent_ = this;
+  if (physical_width_pix_ || physical_height_pix_) {
+    child->OnPhysicalBackingSizeChanged(physical_width_pix_,
+                                        physical_height_pix_);
+  }
 }
 
 void ViewAndroid::RemoveFromParent() {
   if (parent_)
     parent_->RemoveChild(this);
 }
 
 ViewAndroid::ScopedAnchorView ViewAndroid::AcquireAnchorView() {
   ScopedJavaLocalRef<jobject> delegate(GetViewAndroidDelegate());
   if (delegate.is_null())
@@ skipping 32 matching lines @@
       std::find(children_.begin(), children_.end(), child);
   DCHECK(it != children_.end());
   children_.erase(it);
   child->parent_ = nullptr;
 }
 
 WindowAndroid* ViewAndroid::GetWindowAndroid() const {
   return parent_ ? parent_->GetWindowAndroid() : nullptr;
 }
 
+ScopedJavaLocalRef<jobject> ViewAndroid::CreateEventHandler(
+    ViewAndroid* native_view) {
+  return parent_ ? parent_->CreateEventHandler(native_view)

[boliu, 2016/12/08 05:01:06]

this doesn't make any sense to me, why ask the root? EventHandler should be
created directly by ViewAndroid, should not involve WindowAndroid at all

[Jinsuk Kim, 2016/12/13 23:20:38]

This is how I addressed your comment: "creating EventHandler is unnecessarily
duplicated.. is it possible to
have ViewAndroid create the java object and return a JavaRef to it?"
WindowAndroid needs a method creating EventHandler for Chrome, so I'm making use
of it for AW too. Though this is going up to WindowAndroid it doesn't mean
WindowAndroid will have the handler. The method given the ViewAndroid instance
(native_view) which will be associated with it.

Are you suggesting I add createEventHandler in ViewAndroidDelegate too? Then
both WindowAndroid/ViewAndroidDelegate would have a method creating
EventHandler, and I thought it is what you wanted to avoid. See the updated
patch.

Note that not all ViewAndroid has ViewAndroidDelegate. So the request may go up
to parent ViewAndroid  to reach Java layer and have the create object returned.
So the parameter native_view is still necessary.

[boliu, 2016/12/13 23:50:41]

No, I'm suggesting that you mark EventHandler.create @CalledFromNative, and just
call Java_EventHandler_create from here directly.

WindowAndroid doesn't need to be involved at all.

[Jinsuk Kim, 2016/12/14 00:34:08]

Ah much simpler this way. The parameter native_view can go away too. Done. 

+    : ScopedJavaLocalRef<jobject>();
+}
+
 const ScopedJavaLocalRef<jobject> ViewAndroid::GetViewAndroidDelegate()
     const {
   JNIEnv* env = base::android::AttachCurrentThread();
   const ScopedJavaLocalRef<jobject> delegate = delegate_.get(env);
   if (!delegate.is_null())
     return delegate;
 
   return parent_ ? parent_->GetViewAndroidDelegate() : delegate;
 }
 
 cc::Layer* ViewAndroid::GetLayer() const {
   return layer_.get();
 }
 
 void ViewAndroid::SetLayer(scoped_refptr<cc::Layer> layer) {
   layer_ = layer;

[boliu, 2016/12/08 05:01:06]

need to update layer size if new layer is not null

[Jinsuk Kim, 2016/12/13 23:20:38]

Done. Null check is performed in |UpdateLayerBounds|.

 }
 
+ScopedJavaLocalRef<jobject> ViewAndroid::GetEventHandler() {
+  JNIEnv* env = base::android::AttachCurrentThread();
+  const ScopedJavaLocalRef<jobject> handler = event_handler_.get(env);
+  if (!handler.is_null())
+    return handler;
+
+  DCHECK(!HasEventHandlerInTreeHierarchy());
+  event_handler_ = JavaObjectWeakGlobalRef(env, CreateEventHandler(this));
+  return event_handler_.get(env);
+}
+
+bool ViewAndroid::HasEventHandlerInTreeHierarchy() {
+  ViewAndroid* view = parent_;
+  while (view) {
+    if (view->HasEventHandler())
+      return true;
+    view = view->parent_;
+  }
+  return HasEventHandlerInSubtree();
+}
+
+bool ViewAndroid::HasEventHandlerInSubtree() {
+  if (HasEventHandler())
+    return true;
+  for (auto& child : children_) {
+    if (child->HasEventHandlerInSubtree())
+      return true;
+  }
+  return false;
+}
+
 bool ViewAndroid::StartDragAndDrop(const JavaRef<jstring>& jtext,
                                    const JavaRef<jobject>& jimage) {
   ScopedJavaLocalRef<jobject> delegate(GetViewAndroidDelegate());
   if (delegate.is_null())
     return false;
   JNIEnv* env = base::android::AttachCurrentThread();
   return Java_ViewAndroidDelegate_startDragAndDrop(env, delegate, jtext,
                                                    jimage);
 }
 
+gfx::Size ViewAndroid::GetPhysicalBackingSize() {
+  return gfx::Size(physical_width_pix_, physical_height_pix_);
+}
+
+void ViewAndroid::UpdateLayerBounds() {
+  if (layer_)
+    layer_->SetBounds(GetPhysicalBackingSize());
+}
+
+void ViewAndroid::OnPhysicalBackingSizeChanged(int width, int height) {
+  if (width == physical_width_pix_ && height == physical_height_pix_)
+    return;
+
+  SetPhysicalBackingSize(width, height);
+  if (client_)
+    client_->OnPhysicalBackingSizeChanged(width, height);
+
+  for (auto& child : children_)
+    child->OnPhysicalBackingSizeChanged(width, height);
+}
+
 }  // namespace ui