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/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() : parent_(nullptr),
+                             client_(nullptr),
+                             handler_(nullptr) {}
 
 ViewAndroid::~ViewAndroid() {
   RemoveFromParent();
 
   for (std::list<ViewAndroid*>::iterator it = children_.begin();
        it != children_.end(); it++) {
     DCHECK_EQ((*it)->parent_, this);
     (*it)->parent_ = nullptr;
   }
 }
 
 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);
 }
 
+EventHandler* ViewAndroid::GetEventHandler() {
+  if (!parent_ || parent_ == GetWindowAndroid()) {

[boliu, 2016/12/02 23:53:22]

what is the second half of this condition checking? is !parent_ check for root
not enough?

[Jinsuk Kim, 2016/12/05 11:07:44]

In the tree WindowAndroid - ViewAndroid(1) - ViewAndroid(2), I'm adding the
handler in VA(1) not in WA which is the root. Because it won't work for WebView.
VA(1) works for both Chrome and WebView. The second part is actually the
condition that checks if we are VA(1). !parent_ was for sentinel just in case VA
is not linked to WA. I haven't seen it yet though.

[boliu, 2016/12/06 00:10:17]

Ahh I see..

But for chrome (and other non-webview platforms), EventHandler *should* be
created for WindowAndroid.

Also I think GetEventHandler should not be a recursive call. It's more like
"GetOrCreateEventHandlerForThisViewAndroid", which may be illegal and DCHECK if
it violates the above property.

[Jinsuk Kim, 2016/12/06 07:35:07]

Addressed in the new patch.

+    if (!handler_)
+      handler_ = new EventHandler(this);
+    return handler_;
+  }
+  return parent_->GetEventHandler();
+}
+
 void ViewAndroid::AddChild(ViewAndroid* child) {
   DCHECK(child);
   DCHECK(std::find(children_.begin(), children_.end(), child) ==
          children_.end());
 
   children_.push_back(child);
   if (child->parent_)
     child->RemoveFromParent();
   child->parent_ = this;
 }
@@ skipping 69 matching lines @@
 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() {
+  EventHandler* handler = GetEventHandler();
+  if (!handler)
+    return gfx::Size();
+  return gfx::Size(handler->GetPhysicalBackingSizeWidthPix(),
+                   handler->GetPhysicalBackingSizeHeightPix());
+}
+
+bool ViewAndroid::OnPhysicalBackingSizeChanged(int width, int height) {
+  if (client_ && client_->OnPhysicalBackingSizeChanged(width, height))
+    return true;
+  for (auto it = children_.begin(); it != children_.end(); ++it) {
+    if ((*it)->OnPhysicalBackingSizeChanged(width, height))
+      return true;
+  }
+  return false;
+}
+
 }  // namespace ui