Implement new title bar hiding/showing behavior.

Remove the code that hides the title bar when the page finishes loading.
When the user double taps, if it did not result in changing the viewing
mode (i.e. on a mobile site), send a message to the client so we can
toggle the title bar's visibility.  Required for a change to
packages/apps/Browser

Change-Id: I0040fd183ce5673a4069e943f38eb31599c0ca7d

4 files changed, 122 insertions, 54 deletions

diff --git a/core/java/android/webkit/CallbackProxy.java b/core/java/android/webkit/CallbackProxy.java
index e77d29b9ffb2..6abf4c18a99f 100644
--- a/core/java/android/webkit/CallbackProxy.java
+++ b/core/java/android/webkit/CallbackProxy.java
@@ -70,9 +70,6 @@ class CallbackProxy extends Handler {
     private final WebBackForwardList mBackForwardList;
     // Used to call startActivity during url override.
     private final Context mContext;
-    // Stores the URL being loaded and the viewing mode to switch into when
-    // the URL finishes loading.
-    private ChangeViewModeOnFinishedLoad mChange;
 
     // Message Ids
     private static final int PAGE_STARTED                        = 100;
@@ -181,36 +178,16 @@ class CallbackProxy extends Handler {
 
     /**
      * Tell the host application that the WebView has changed viewing modes.
-     * @param toZoomedOut If true, the WebView has zoomed out so that the page
-     *          fits the screen.  If false, it is zoomed to the setting
-     *          specified by the user.
+     * @param newViewingMode  One of the values described in WebView as possible
+     *                        values for the viewing mode
      */
-    /* package */ void uiOnChangeViewingMode(boolean toZoomOverview) {
+    /* package */ void uiOnChangeViewingMode(int newViewingMode) {
         if (mWebChromeClient != null) {
-            mWebChromeClient.onChangeViewingMode(toZoomOverview);
-        }
-    }
-
-    private static class ChangeViewModeOnFinishedLoad {
-        boolean mToZoomOverView;
-        String mOriginalUrl;
-        ChangeViewModeOnFinishedLoad(boolean toZoomOverview,
-                String originalUrl) {
-            mToZoomOverView = toZoomOverview;
-            mOriginalUrl = originalUrl;
+            mWebChromeClient.onChangeViewingMode(mWebView, newViewingMode);
         }
     }
 
     /**
-     * Keep track of the url and the viewing mode to change into.  If/when that
-     * url finishes loading, this will change the viewing mode.
-     */
-    /* package */ void uiChangeViewingModeOnFinishedLoad(
-            boolean toZoomOverview, String originalUrl) {
-        if (mWebChromeClient == null) return;
-        mChange = new ChangeViewModeOnFinishedLoad(toZoomOverview, originalUrl);
-    }
-    /**
      * Called by the UI side.  Calling overrideUrlLoading from the WebCore
      * side will post a message to call this method.
      */
@@ -271,15 +248,6 @@ class CallbackProxy extends Handler {
                 if (mWebViewClient != null) {
                     mWebViewClient.onPageFinished(mWebView, (String) msg.obj);
                 }
-                if (mChange != null) {
-                    if (mWebView.getOriginalUrl().equals(mChange.mOriginalUrl)) {
-                        uiOnChangeViewingMode(mChange.mToZoomOverView);
-                    } else {
-                        // The user has gone to a different page, so there is
-                        // no need to hang on to the old object.
-                        mChange = null;
-                    }
-                }
                 break;
                 
             case RECEIVED_ICON:
diff --git a/core/java/android/webkit/WebChromeClient.java b/core/java/android/webkit/WebChromeClient.java
index e1c8d4da409a..e2d5d24ee9a8 100644
--- a/core/java/android/webkit/WebChromeClient.java
+++ b/core/java/android/webkit/WebChromeClient.java
@@ -24,12 +24,12 @@ public class WebChromeClient {
 
     /**
      * Tell the host application that the WebView has changed viewing modes.
-     * @param toZoomedOut If true, the WebView has zoomed out so that the page
-     *          fits the screen.  If false, it is zoomed to the setting
-     *          specified by the user.
+     * @param view The WebView that initiated the callback.
+     * @param newViewingMode  One of the values described in WebView as possible
+     *                        values for the viewing mode
      * @hide
      */
-    public void onChangeViewingMode(boolean toZoomedOut) {}
+    public void onChangeViewingMode(WebView view, int newViewingMode) {}
 
     /**
      * Tell the host application the current progress of loading a page.
diff --git a/core/java/android/webkit/WebView.java b/core/java/android/webkit/WebView.java
index 3c93fb0b5ece..196c66bf5f5f 100644
--- a/core/java/android/webkit/WebView.java
+++ b/core/java/android/webkit/WebView.java
@@ -522,6 +522,48 @@ public class WebView extends AbsoluteLayout
     // the last zoom scale.
     boolean mInZoomOverview = false;
 
+    // The viewing mode of this webview.  Reported back to the WebChromeClient
+    // so we can hide and display the title bar as appropriate.
+    private int mViewingMode;
+    /**
+     * Not supporting overview vs reading mode
+     * @hide
+     */
+    public final static int NO_VIEWING_MODE = 0;
+    /**
+     * Zoom overview mode.  The page is zoomed all the way out, mInZoomOverview
+     * is true, and the title bar is showing.  Double tapping will change to
+     * reading mode.
+     * @hide
+     */
+    public final static int OVERVIEW_MODE = 1;
+    /**
+     * Reading mode. The page is at the level specified by the user,
+     * mInZoomOverview is false, and the title bar is not showing.  Double
+     * tapping will change to zoom overview mode.
+     * @hide
+     */
+    public final static int READING_MODE = 2;
+    /**
+     * Modified reading mode, which shows the title bar.  mInZoomOverview is
+     * false, and double tapping will change to zoom overview mode.  However,
+     * if the scrolling will change to reading mode.  Used when swiping a
+     * tab into view which was in reading mode, unless it was a mobile site
+     * with zero scroll.
+     * @hide
+     */
+    public final static int READING_MODE_WITH_TITLE_BAR = 3;
+    /**
+     * Another modified reading mode.  For loading a mobile site, or swiping a
+     * tab into view which was displaying a mobile site in reading mode
+     * with zero scroll
+     * @hide
+     */
+    public final static int TITLE_BAR_DISMISS_MODE = 4;
+    // Whether the current site is a mobile site.  Determined when we receive
+    // NEW_PICTURE_MSG_ID to help determine how to handle double taps
+    private boolean mMobileSite;
+
     // ideally mZoomOverviewWidth should be mContentWidth. But sites like espn,
     // engadget always have wider mContentWidth no matter what viewport size is.
     int mZoomOverviewWidth = WebViewCore.DEFAULT_VIEWPORT_WIDTH;
@@ -1135,6 +1177,7 @@ public class WebView extends AbsoluteLayout
             if (mInZoomOverview) {
                 b.putFloat("lastScale", mLastScale);
             }
+            b.putBoolean("mobile", mMobileSite);
             return true;
         }
         return false;
@@ -1180,12 +1223,20 @@ public class WebView extends AbsoluteLayout
                 // correctly
                 mActualScale = scale;
                 float lastScale = b.getFloat("lastScale", -1.0f);
+                mMobileSite = b.getBoolean("mobile", false);
                 if (lastScale > 0) {
                     mInZoomOverview = true;
+                    mViewingMode = OVERVIEW_MODE;
                     mLastScale = lastScale;
                 } else {
                     mInZoomOverview = false;
+                    if (mMobileSite && (mScrollX | mScrollY) == 0) {
+                        mViewingMode = TITLE_BAR_DISMISS_MODE;
+                    } else {
+                        mViewingMode = READING_MODE_WITH_TITLE_BAR;
+                    }
                 }
+                mCallbackProxy.uiOnChangeViewingMode(mViewingMode);
                 invalidate();
                 return true;
             }
@@ -3695,6 +3746,12 @@ public class WebView extends AbsoluteLayout
     protected void onScrollChanged(int l, int t, int oldl, int oldt) {
         super.onScrollChanged(l, t, oldl, oldt);
 
+        if (mViewingMode == READING_MODE_WITH_TITLE_BAR
+                || mViewingMode == TITLE_BAR_DISMISS_MODE) {
+            mViewingMode = READING_MODE;
+            mCallbackProxy.uiOnChangeViewingMode(mViewingMode);
+        }
+
         sendOurVisibleRect();
     }
 
@@ -3909,6 +3966,13 @@ public class WebView extends AbsoluteLayout
                 deltaY = newScrollY - mScrollY;
                 boolean done = false;
                 if (deltaX == 0 && deltaY == 0) {
+                    // The user attempted to pan the page, so dismiss the title
+                    // bar
+                    if (mViewingMode == READING_MODE_WITH_TITLE_BAR
+                            || mViewingMode == TITLE_BAR_DISMISS_MODE) {
+                        mViewingMode = READING_MODE;
+                        mCallbackProxy.uiOnChangeViewingMode(mViewingMode);
+                    }
                     done = true;
                 } else {
                     if (mSnapScrollMode == SNAP_X || mSnapScrollMode == SNAP_Y) {
@@ -4683,14 +4747,42 @@ public class WebView extends AbsoluteLayout
         }
     }
 
+    /**
+     * Called when the Tabs are used to slide this WebView's tab into view.
+     * @hide
+     */
+    public void slideIntoFocus() {
+        if (mViewingMode == READING_MODE) {
+            if (!mMobileSite || (mScrollX | mScrollY) != 0) {
+                mViewingMode = READING_MODE_WITH_TITLE_BAR;
+            } else {
+                mViewingMode = TITLE_BAR_DISMISS_MODE;
+            }
+            mCallbackProxy.uiOnChangeViewingMode(mViewingMode);
+        }
+    }
+
     private void doDoubleTap() {
-        if (mWebViewCore.getSettings().getUseWideViewPort() == false) {
+        if (mWebViewCore.getSettings().getUseWideViewPort() == false ||
+                mViewingMode == NO_VIEWING_MODE) {
+            return;
+        }
+        if (mViewingMode == TITLE_BAR_DISMISS_MODE) {
+            mViewingMode = READING_MODE;
+            // mInZoomOverview will not change, so change the viewing mode
+            // and return
+            mCallbackProxy.uiOnChangeViewingMode(mViewingMode);
             return;
         }
+        if (mViewingMode == READING_MODE_WITH_TITLE_BAR && mMobileSite) {
+            scrollTo(0,0);
+        }
+        // READING_MODE_WITH_TITLE_BAR will go to OVERVIEW_MODE here.
         mZoomCenterX = mLastTouchX;
         mZoomCenterY = mLastTouchY;
         mInZoomOverview = !mInZoomOverview;
-        mCallbackProxy.uiOnChangeViewingMode(mInZoomOverview);
+        mViewingMode = mInZoomOverview ? OVERVIEW_MODE : READING_MODE;
+        mCallbackProxy.uiOnChangeViewingMode(mViewingMode);
         // remove the zoom control after double tap
         if (getSettings().getBuiltInZoomControls()) {
             if (mZoomButtonsController.isVisible()) {
@@ -5035,21 +5127,27 @@ public class WebView extends AbsoluteLayout
                         } else {
                             mMaxZoomScale = restoreState.mMaxScale;
                         }
-                        if (useWideViewport && restoreState.mViewScale == 0) {
-                            mInZoomOverview = ENABLE_DOUBLETAP_ZOOM
-                                    && settings.getLoadWithOverviewMode();
-                        }
-                        mCallbackProxy.uiOnChangeViewingMode(true);
-                        if (!mInZoomOverview) {
-                            // We are going to start zoomed in.  However, we
-                            // truly want to show the title bar, and then hide
-                            // it once the page has loaded
-                            mCallbackProxy.uiChangeViewingModeOnFinishedLoad(
-                                    false, getOriginalUrl());
-                        }
                         setNewZoomScale(mLastScale, false);
                         setContentScrollTo(restoreState.mScrollX,
                                 restoreState.mScrollY);
+                        if (!ENABLE_DOUBLETAP_ZOOM
+                                || !settings.getLoadWithOverviewMode()) {
+                            mMobileSite = false;
+                            mViewingMode = NO_VIEWING_MODE;
+                        } else {
+                            mMobileSite = restoreState.mMobileSite;
+                            if (useWideViewport
+                                    && restoreState.mViewScale == 0) {
+                                mViewingMode = OVERVIEW_MODE;
+                                mInZoomOverview = true;
+                            } else if (mMobileSite
+                                    && (mScrollX | mScrollY) == 0) {
+                                mViewingMode = TITLE_BAR_DISMISS_MODE;
+                            } else {
+                                mViewingMode = READING_MODE_WITH_TITLE_BAR;
+                            }
+                        }
+                        mCallbackProxy.uiOnChangeViewingMode(mViewingMode);
                         // As we are on a new page, remove the WebTextView. This
                         // is necessary for page loads driven by webkit, and in
                         // particular when the user was on a password field, so
diff --git a/core/java/android/webkit/WebViewCore.java b/core/java/android/webkit/WebViewCore.java
index dee62b41463a..d6a9cffdc5be 100644
--- a/core/java/android/webkit/WebViewCore.java
+++ b/core/java/android/webkit/WebViewCore.java
@@ -1505,6 +1505,7 @@ final class WebViewCore {
         float mTextWrapScale;
         int mScrollX;
         int mScrollY;
+        boolean mMobileSite;
     }
 
     static class DrawData {
@@ -1859,6 +1860,7 @@ final class WebViewCore {
         mRestoreState.mMaxScale = mViewportMaximumScale / 100.0f;
         mRestoreState.mScrollX = mRestoredX;
         mRestoreState.mScrollY = mRestoredY;
+        mRestoreState.mMobileSite = (0 == mViewportWidth);
         if (mRestoredScale > 0) {
             if (mRestoredScreenWidthScale > 0) {
                 mRestoreState.mTextWrapScale =