Store physical backing size in ViewAndroid

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 "base/android/jni_string.h"
@@ skipping 105 matching lines @@
   DCHECK(std::find(children_.begin(), children_.end(), child) ==
          children_.end());
   DCHECK(!SubtreeHasEventForwarder(child) || !ViewTreeHasEventForwarder(this))
       << "Only one event handler is allowed.";
 
   // The new child goes to the top, which is the end of the list.
   children_.push_back(child);
   if (child->parent_)
     child->RemoveFromParent();
   child->parent_ = this;
+  child->OnPhysicalBackingSizeChanged(physical_size_);
 }
 
 // static
 bool ViewAndroid::ViewTreeHasEventForwarder(ViewAndroid* view) {
   ViewAndroid* v = view;
   do {
     if (v->has_event_forwarder())
       return true;
     v = v->parent_;
   } while (v);
@@ skipping 86 matching lines @@
 }
 
 cc::Layer* ViewAndroid::GetLayer() const {
   return layer_.get();
 }
 
 void ViewAndroid::SetLayer(scoped_refptr<cc::Layer> layer) {
   layer_ = layer;
 }
 
+void ViewAndroid::UpdateLayerBounds() {
+  if (layer_)
+    layer_->SetBounds(physical_size_);
+}
+
 void ViewAndroid::SetLayout(ViewAndroid::LayoutParams params) {
   layout_params_ = params;
 }
 
 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();
@@ skipping 30 matching lines @@
 }
 
 int ViewAndroid::GetSystemWindowInsetBottom() {
   ScopedJavaLocalRef<jobject> delegate(GetViewAndroidDelegate());
   if (delegate.is_null())
     return 0;
   JNIEnv* env = base::android::AttachCurrentThread();
   return Java_ViewAndroidDelegate_getSystemWindowInsetBottom(env, delegate);
 }
 
+void ViewAndroid::OnPhysicalBackingSizeChanged(const gfx::Size& size) {
+  if (physical_size_ == size)
+    return;
+  physical_size_ = size;
+  UpdateLayerBounds();
+  if (client_ && client_->OnPhysicalBackingSizeChanged())

[boliu, 2017/04/29 00:18:40]

this makes no sense, why would client ever want to cancel this?

looking at the use cases, looks like returning false in cases where
OnPhysicalBackingSizeChanged currently returns true works just fine?

[Jinsuk Kim, 2017/04/30 00:23:50]

Can do without bool return type. Changed to void.

+    return;
+
+  for (auto* child : children_)
+    child->OnPhysicalBackingSizeChanged(size);
+}
+
+gfx::Size ViewAndroid::GetPhysicalBackingSize() {
+  return physical_size_;
+}
+
 bool ViewAndroid::OnTouchEvent(const MotionEventAndroid& event,
                                bool for_touch_handle) {
   return HitTest(
       base::Bind(&ViewAndroid::SendTouchEventToClient, for_touch_handle),
       event);
 }
 
 bool ViewAndroid::SendTouchEventToClient(bool for_touch_handle,
                                          ViewClient* client,
                                          const MotionEventAndroid& event) {
@@ skipping 40 matching lines @@
         matched = bound.Contains(e->GetX(0), e->GetY(0));
       }
       if (matched && child->HitTest(send_to_client, *e))
         return true;
     }
   }
   return false;
 }
 
 }  // namespace ui