[Contextual Search] Fixing ViewResourceInflater layout invalidation.

ui/android/java/src/org/chromium/ui/resources/dynamics/ViewResourceInflater.java

 // Copyright 2015 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.ui.resources.dynamics;
 
 import android.content.Context;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
@@ skipping 102 matching lines @@
 
         // Inflate the View without attaching to hierarchy (attachToRoot param is false).
         mView = LayoutInflater.from(mContext).inflate(mLayoutId, mContainer, false);
 
         // Make sure the View we just inflated is the right one.
         assert mView.getId() == mViewId;
 
         // Allow subclasses to access/modify the View before it's attached
         // to the hierarchy (if allowed) or snapshots are captured.
         onFinishInflate();
-
-        registerResource();
     }
 
     /**
      * Invalidate the inflated View, causing a snapshot of the View to be captured.
      */
     public void invalidate() {
-        // View must be inflated at this point. If it's not, do it now.
-        if (mView == null) {
-            inflate();
-        }
-
-        mIsInvalidated = true;
-
-        // If the View is already attached, we don't need to do anything because the
-        // snapshot will be captured automatically when the View is drawn.
-        if (!mIsAttached) {
-            if (shouldAttachView()) {
-                // TODO(pedrosimonetti): investigate if complex views can be rendered offline.
-                // NOTE(pedrosimonetti): it seems that complex views don't get rendered
-                // properly if not attached to the hierarchy. The problem seem to be related
-                // to the use of the property "layout_gravity: end", possibly in combination
-                // of other things like elastic views (layout_weight: 1) and/or fading edges.
-                attachView();
-            } else {
-                // When the View is not attached, we need to manually layout the View
-                // and invalidate the resource in order to capture a new snapshot.
-                layout();
-                invalidateResource();
-            }
-        }
+        invalidate(false);
     }
 
     /**
+     * Request a layout update, causing the {@link ViewResourceInflater} to be invalidated.
+     */
+    public void requestLayout() {
+        invalidate(true);
+    }
+
+    /**
      * Destroy the instance.
      */
     public void destroy() {
         if (mView == null) return;
 
         unregisterResource();
 
         detachView();
         mView = null;
 
@@ skipping 107 matching lines @@
                 mView.getViewTreeObserver().removeOnDrawListener(mOnDrawListener);
                 mOnDrawListener = null;
             }
 
             assert mView.getParent() != null;
             mContainer.removeView(mView);
             mIsAttached = false;
         }
     }
 
+    private void invalidate(boolean requestLayout) {
+        // View must be inflated at this point. If it's not, do it now.
+        if (mView == null) {
+            inflate();
+        }
+
+        // Layout the View if necessary, updating its size.
+        if (requestLayout) {
+            layout(true);
+        }
+
+        // Register the resource, if not registered yet.
+        if (mResourceAdapter == null) {
+            registerResource();
+        }
+
+        mIsInvalidated = true;
+
+        if (!mIsAttached && shouldAttachView()) {
+            // TODO(pedrosimonetti): investigate if complex views can be rendered offline.
+            // NOTE(pedrosimonetti): it seems that complex views don't get rendered
+            // properly if not attached to the hierarchy. The problem seem to be related
+            // to the use of the property "layout_gravity: end", possibly in combination
+            // of other things like elastic views (layout_weight: 1) and/or fading edges.
+            attachView();
+        }
+
+        if (!mIsAttached) {
+            // When the View is not attached, we need to manually layout the View and
+            // invalidate the resource in order to capture a new snapshot.
+            layout(false);
+            invalidateResource();
+        }
+    }
+
     /**
-     * Layout the View. This is to be used when the View is not attached to the hierarchy.
+     * Lays out the view according to the current width and height measure specs.
      */
-    private void layout() {
+    private void layout(boolean updateLayoutParams) {
         // View must be inflated at this point.
         assert mView != null;
 
+        // Update LayoutParams according to the current measure spec.
+        if (updateLayoutParams) {
+            final int widthMeasureSpec = getWidthMeasureSpec();
+            int width = ViewGroup.LayoutParams.WRAP_CONTENT;
+            if (View.MeasureSpec.getMode(widthMeasureSpec) == View.MeasureSpec.EXACTLY) {
+                width = View.MeasureSpec.getSize(widthMeasureSpec);
+            }
+
+            final int heightMeasureSpec = getHeightMeasureSpec();
+            int height = ViewGroup.LayoutParams.WRAP_CONTENT;
+            if (View.MeasureSpec.getMode(heightMeasureSpec) == View.MeasureSpec.EXACTLY) {
+                height = View.MeasureSpec.getSize(heightMeasureSpec);
+            }
+
+            ViewGroup.LayoutParams params = mView.getLayoutParams();
+            params.width = width;
+            params.height = height;
+            mView.setLayoutParams(params);
+        }
+
         mView.measure(getWidthMeasureSpec(), getHeightMeasureSpec());

[newt (away), 2016/03/24 22:31:36]

If you're going to attach this view to the view hierarchy, there's no point in
measuring and laying it out in advance; it'll just get measured and laid out
again once it's attached to the hierarchy. So, I'd skip these lines in that
case.

[pedro (no code reviews), 2016/03/25 00:37:47]

Made changes based on our offline discussion.

         mView.layout(0, 0, getMeasuredWidth(), getMeasuredHeight());
     }
 
     /**
      * @return An unspecified MeasureSpec value.
      */
     private int getUnspecifiedMeasureSpec() {
         return View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED);
     }
 
@@ skipping 64 matching lines @@
         }
     }
 
     /**
      * Called when the View is drawn,
      */
     private void onDraw() {
         invalidateResource();
     }
 }