src/com/android/browser/BaseUi.java

/*
 * Copyright (C) 2010 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.browser;

import android.app.ActionBar;
import android.app.Activity;
import android.content.Context;
import android.content.res.Configuration;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.PixelFormat;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.text.TextUtils;
import android.util.Log;
import android.view.ActionMode;
import android.view.Gravity;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import android.view.WindowManager;
import android.webkit.WebChromeClient;
import android.webkit.WebHistoryItem;
import android.webkit.WebView;
import android.widget.FrameLayout;
import android.widget.LinearLayout;
import android.widget.Toast;

import java.util.List;

/**
 * UI interface definitions
 */
public class BaseUi implements UI, WebViewFactory {

    private static final String LOGTAG = "BaseUi";

    private static final FrameLayout.LayoutParams COVER_SCREEN_PARAMS =
        new FrameLayout.LayoutParams(
        ViewGroup.LayoutParams.MATCH_PARENT,
        ViewGroup.LayoutParams.MATCH_PARENT);

    private static final FrameLayout.LayoutParams COVER_SCREEN_GRAVITY_CENTER =
        new FrameLayout.LayoutParams(
        ViewGroup.LayoutParams.MATCH_PARENT,
        ViewGroup.LayoutParams.MATCH_PARENT,
        Gravity.CENTER);

    Activity mActivity;
    UiController mUiController;
    TabControl mTabControl;
    private Tab mActiveTab;

    private Drawable mSecLockIcon;
    private Drawable mMixLockIcon;

    private boolean mXLargeScreenSize;
    private FrameLayout mBrowserFrameLayout;
    private FrameLayout mContentView;
    private FrameLayout mCustomViewContainer;
    private TitleBarBase mTitleBar;
    private TitleBarBase mFakeTitleBar;
    private TabBar mTabBar;

    private View mCustomView;
    private WebChromeClient.CustomViewCallback mCustomViewCallback;

    private CombinedBookmarkHistoryView mComboView;

    private LinearLayout mErrorConsoleContainer = null;

    private Toast mStopToast;
    private ActiveTabsPage mActiveTabsPage;

    // the default <video> poster
    private Bitmap mDefaultVideoPoster;
    // the video progress view
    private View mVideoProgressView;

    boolean mExtendedMenuOpen;
    boolean mOptionsMenuOpen;

    private boolean mActivityPaused;

    public BaseUi(Activity browser, UiController controller) {
        mActivity = browser;
        mUiController = controller;
        mTabControl = controller.getTabControl();
        Resources res = mActivity.getResources();
        mSecLockIcon = res.getDrawable(R.drawable.ic_secure);
        mMixLockIcon = res.getDrawable(R.drawable.ic_partial_secure);


        mXLargeScreenSize = (res.getConfiguration().screenLayout
                & Configuration.SCREENLAYOUT_SIZE_MASK)
                == Configuration.SCREENLAYOUT_SIZE_XLARGE;

        FrameLayout frameLayout = (FrameLayout) mActivity.getWindow()
                .getDecorView().findViewById(android.R.id.content);
        mBrowserFrameLayout = (FrameLayout) LayoutInflater.from(mActivity)
                .inflate(R.layout.custom_screen, null);
        mContentView = (FrameLayout) mBrowserFrameLayout.findViewById(
                R.id.main_content);
        mErrorConsoleContainer = (LinearLayout) mBrowserFrameLayout
                .findViewById(R.id.error_console);
        mCustomViewContainer = (FrameLayout) mBrowserFrameLayout
                .findViewById(R.id.fullscreen_custom_content);
        frameLayout.addView(mBrowserFrameLayout, COVER_SCREEN_PARAMS);

        if (mXLargeScreenSize) {
            mTitleBar = new TitleBarXLarge(mActivity, mUiController);
            mTitleBar.setProgress(100);
            mFakeTitleBar = new TitleBarXLarge(mActivity, mUiController);
            ActionBar actionBar = mActivity.getActionBar();
            mTabBar = new TabBar(mActivity, mUiController, this);
            actionBar.setCustomNavigationMode(mTabBar);
        } else {
            mTitleBar = new TitleBar(mActivity, mUiController);
            // mTitleBar will be always be shown in the fully loaded mode on
            // phone
            mTitleBar.setProgress(100);
            mFakeTitleBar = new TitleBar(mActivity, mUiController);
        }
    }

    // webview factory

    @Override
    public WebView createWebView(boolean privateBrowsing) {
        // Create a new WebView
        ScrollWebView w = new ScrollWebView(mActivity, null,
                android.R.attr.webViewStyle, privateBrowsing);
        w.setScrollbarFadingEnabled(true);
        w.setScrollBarStyle(View.SCROLLBARS_OUTSIDE_OVERLAY);
        w.setMapTrackballToArrowKeys(false); // use trackball directly
        // Enable the built-in zoom
        w.getSettings().setBuiltInZoomControls(true);
        if (mXLargeScreenSize) {
            w.setScrollListener(mTabBar);
            w.getSettings().setDisplayZoomControls(false);
        }

        // Add this WebView to the settings observer list and update the
        // settings
        final BrowserSettings s = BrowserSettings.getInstance();
        s.addObserver(w.getSettings()).update(s, null);
        return w;
    }

    void stopWebViewScrolling() {
        ScrollWebView web = (ScrollWebView) mUiController.getCurrentWebView();
        if (web != null) {
            web.stopScroll();
        }
    }

    private void cancelStopToast() {
        if (mStopToast != null) {
            mStopToast.cancel();
            mStopToast = null;
        }
    }

    // lifecycle

    public void onPause() {
        // FIXME: This removes the active tabs page and resets the menu to
        // MAIN_MENU.  A better solution might be to do this work in onNewIntent
        // but then we would need to save it in onSaveInstanceState and restore
        // it in onCreate/onRestoreInstanceState
        if (mActiveTabsPage != null) {
            mUiController.removeActiveTabsPage(true);
        }
        cancelStopToast();
        mActivityPaused = true;
    }

    public void onResume() {
        mActivityPaused = false;
    }

    public void onDestroy() {
        hideFakeTitleBar();
    }

    public void onConfigurationChanged(Configuration config) {
    }

    // key handling

    @Override
    public boolean onBackKey() {
        if (mActiveTabsPage != null) {
            // if tab page is showing, hide it
            mUiController.removeActiveTabsPage(true);
            return true;
        }
        if (mComboView != null) {
            if (!mComboView.onBackPressed()) {
                mUiController.removeComboView();
            }
            return true;
        }
        if (mCustomView != null) {
            mUiController.hideCustomView();
            return true;
        }
        return false;
    }

    // WebView callbacks

    @Override
    public void onPageStarted(Tab tab, String url, Bitmap favicon) {
        if (mXLargeScreenSize) {
            mTabBar.onPageStarted(tab, url, favicon);
        }
        if (tab.inForeground()) {
            resetLockIcon(tab, url);
            setUrlTitle(tab, url, null);
            setFavicon(tab, favicon);
        }

    }

    @Override
    public void onPageFinished(Tab tab, String url) {
        if (mXLargeScreenSize) {
            mTabBar.onPageFinished(tab);
        }
        if (tab.inForeground()) {
            // Reset the title and icon in case we stopped a provisional load.
            resetTitleAndIcon(tab);
            // Update the lock icon image only once we are done loading
            updateLockIconToLatest(tab);
        }
    }

    @Override
    public void onPageStopped(Tab tab) {
        cancelStopToast();
        if (tab.inForeground()) {
            mStopToast = Toast
                    .makeText(mActivity, R.string.stopping, Toast.LENGTH_SHORT);
            mStopToast.show();
        }
    }

    @Override
    public void onProgressChanged(Tab tab, int progress) {
        if (mXLargeScreenSize) {
            mTabBar.onProgress(tab, progress);
        }
        if (tab.inForeground()) {
            mFakeTitleBar.setProgress(progress);
            if (progress == 100) {
                if (!mOptionsMenuOpen || !mExtendedMenuOpen) {
                    hideFakeTitleBar();
                }
            } else {
                if (!mOptionsMenuOpen || mExtendedMenuOpen) {
                    showFakeTitleBar();
                }
            }
        }
    }

    @Override
    public boolean needsRestoreAllTabs() {
        return mXLargeScreenSize;
    }

    @Override
    public void addTab(Tab tab) {
        if (mXLargeScreenSize) {
            mTabBar.onNewTab(tab);
        }
    }

    @Override
    public void setActiveTab(Tab tab) {
        if ((tab != mActiveTab) && (mActiveTab != null)) {
            removeTabFromContentView(mActiveTab);
        }
        mActiveTab = tab;
        attachTabToContentView(tab);
        setShouldShowErrorConsole(tab, mUiController.shouldShowErrorConsole());

        WebView view = tab.getWebView();
        // TabControl.setCurrentTab has been called before this,
        // so the tab is guaranteed to have a webview
        if (view == null) {
            Log.e(LOGTAG, "active tab with no webview detected");
            return;
        }
        view.setEmbeddedTitleBar(mTitleBar);
        if (tab.isInVoiceSearchMode()) {
            showVoiceTitleBar(tab.getVoiceDisplayTitle());
        } else {
            revertVoiceTitleBar(tab);
        }

        if (mXLargeScreenSize) {
            // Request focus on the top window.
            mTabBar.onSetActiveTab(tab);
        }
        resetTitleIconAndProgress(tab);
        updateLockIconToLatest(tab);
        tab.getTopWindow().requestFocus();
    }

    @Override
    public void updateTabs(List<Tab> tabs) {
        if (mXLargeScreenSize) {
            mTabBar.updateTabs(tabs);
        }
    }

    @Override
    public void removeTab(Tab tab) {
        if (mActiveTab == tab) {
            removeTabFromContentView(tab);
            mActiveTab = null;
        }
        if (mXLargeScreenSize) {
            mTabBar.onRemoveTab(tab);
        }
    }

    @Override
    public void detachTab(Tab tab) {
        removeTabFromContentView(tab);
    }

    @Override
    public void attachTab(Tab tab) {
        attachTabToContentView(tab);
    }

    private void attachTabToContentView(Tab tab) {
        if (tab.getWebView() == null) {
            return;
        }
        View container = tab.getViewContainer();
        WebView mainView  = tab.getWebView();
        // Attach the WebView to the container and then attach the
        // container to the content view.
        FrameLayout wrapper =
                (FrameLayout) container.findViewById(R.id.webview_wrapper);
        ViewGroup parent = (ViewGroup) mainView.getParent();
        if (parent != wrapper) {
            if (parent != null) {
                Log.w(LOGTAG, "mMainView already has a parent in"
                        + " attachTabToContentView!");
                parent.removeView(mainView);
            }
            wrapper.addView(mainView);
        } else {
            Log.w(LOGTAG, "mMainView is already attached to wrapper in"
                    + " attachTabToContentView!");
        }
        parent = (ViewGroup) container.getParent();
        if (parent != mContentView) {
            if (parent != null) {
                Log.w(LOGTAG, "mContainer already has a parent in"
                        + " attachTabToContentView!");
                parent.removeView(container);
            }
            mContentView.addView(container, COVER_SCREEN_PARAMS);
        } else {
            Log.w(LOGTAG, "mContainer is already attached to content in"
                    + " attachTabToContentView!");
        }
        mUiController.attachSubWindow(tab);
    }

    private void removeTabFromContentView(Tab tab) {
        // Remove the container that contains the main WebView.
        WebView mainView = tab.getWebView();
        View container = tab.getViewContainer();
        if (mainView == null) {
            return;
        }
        // Remove the container from the content and then remove the
        // WebView from the container. This will trigger a focus change
        // needed by WebView.
        FrameLayout wrapper =
                (FrameLayout) container.findViewById(R.id.webview_wrapper);
        wrapper.removeView(mainView);
        mContentView.removeView(container);
        mUiController.endActionMode();
        mUiController.removeSubWindow(tab);
        ErrorConsoleView errorConsole = tab.getErrorConsole(false);
        if (errorConsole != null) {
            mErrorConsoleContainer.removeView(errorConsole);
        }
        mainView.setEmbeddedTitleBar(null);
    }

    /**
     * Remove the sub window from the content view.
     */
    @Override
    public void removeSubWindow(View subviewContainer) {
        mContentView.removeView(subviewContainer);
        mUiController.endActionMode();
    }

    /**
     * Attach the sub window to the content view.
     */
    @Override
    public void attachSubWindow(View container) {
        mContentView.addView(container, COVER_SCREEN_PARAMS);
    }

    void showFakeTitleBar() {
        if (!isFakeTitleBarShowing() && mActiveTabsPage == null &&
                !mActivityPaused) {
            WebView mainView = mUiController.getCurrentWebView();
            // if there is no current WebView, don't show the faked title bar;
            if (mainView == null) {
                return;
            }
            // Do not need to check for null, since the current tab will have
            // at least a main WebView, or we would have returned above.
            if (mUiController.isInCustomActionMode()) {
                // Do not show the fake title bar, while a custom ActionMode
                // (i.e. find or select) is showing.
                return;
            }
            if (mXLargeScreenSize) {
                mContentView.addView(mFakeTitleBar);
                mTabBar.onShowTitleBar();
            } else {
                WindowManager manager = (WindowManager)
                        mActivity.getSystemService(Context.WINDOW_SERVICE);

                // Add the title bar to the window manager so it can receive
                // touches
                // while the menu is up
                WindowManager.LayoutParams params =
                        new WindowManager.LayoutParams(
                                ViewGroup.LayoutParams.MATCH_PARENT,
                                ViewGroup.LayoutParams.WRAP_CONTENT,
                                WindowManager.LayoutParams.TYPE_APPLICATION,
                                WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE,
                                PixelFormat.TRANSLUCENT);
                params.gravity = Gravity.TOP;
                boolean atTop = mainView.getScrollY() == 0;
                params.windowAnimations = atTop ? 0 : R.style.TitleBar;
                manager.addView(mFakeTitleBar, params);
            }
        }
    }

    void hideFakeTitleBar() {
        if (!isFakeTitleBarShowing()) return;
        if (mXLargeScreenSize) {
            mContentView.removeView(mFakeTitleBar);
            mTabBar.onHideTitleBar();
        } else {
            WindowManager.LayoutParams params =
                    (WindowManager.LayoutParams) mFakeTitleBar.getLayoutParams();
            WebView mainView = mUiController.getCurrentWebView();
            // Although we decided whether or not to animate based on the
            // current
            // scroll position, the scroll position may have changed since the
            // fake title bar was displayed. Make sure it has the appropriate
            // animation/lack thereof before removing.
            params.windowAnimations =
                    mainView != null && mainView.getScrollY() == 0 ?
                            0 : R.style.TitleBar;
            WindowManager manager = (WindowManager) mActivity
                    .getSystemService(Context.WINDOW_SERVICE);
            manager.updateViewLayout(mFakeTitleBar, params);
            manager.removeView(mFakeTitleBar);
        }
    }

    boolean isFakeTitleBarShowing() {
        return (mFakeTitleBar.getParent() != null);
    }

    @Override
    public void showComboView(boolean startWithHistory, Bundle extras) {
        mComboView = new CombinedBookmarkHistoryView(mActivity,
                mUiController,
                startWithHistory ?
                        CombinedBookmarkHistoryView.FRAGMENT_ID_HISTORY
                        : CombinedBookmarkHistoryView.FRAGMENT_ID_BOOKMARKS,
                extras);
        mTitleBar.setVisibility(View.GONE);
        hideFakeTitleBar();
        mContentView.addView(mComboView, COVER_SCREEN_PARAMS);
    }

    /**
     * dismiss the ComboPage
     */
    @Override
    public void hideComboView() {
        if (mComboView != null) {
            mContentView.removeView(mComboView);
            mTitleBar.setVisibility(View.VISIBLE);
            mComboView = null;
        }
    }

    @Override
    public void showCustomView(View view,
            WebChromeClient.CustomViewCallback callback) {
        // if a view already exists then immediately terminate the new one
        if (mCustomView != null) {
            callback.onCustomViewHidden();
            return;
        }

        // Add the custom view to its container.
        mCustomViewContainer.addView(view, COVER_SCREEN_GRAVITY_CENTER);
        mCustomView = view;
        mCustomViewCallback = callback;
        // Hide the content view.
        mContentView.setVisibility(View.GONE);
        // Finally show the custom view container.
        setStatusBarVisibility(false);
        mCustomViewContainer.setVisibility(View.VISIBLE);
        mCustomViewContainer.bringToFront();
    }

    @Override
    public void onHideCustomView() {
        if (mCustomView == null)
            return;

        // Hide the custom view.
        mCustomView.setVisibility(View.GONE);
        // Remove the custom view from its container.
        mCustomViewContainer.removeView(mCustomView);
        mCustomView = null;
        mCustomViewContainer.setVisibility(View.GONE);
        mCustomViewCallback.onCustomViewHidden();
        // Show the content view.
        setStatusBarVisibility(true);
        mContentView.setVisibility(View.VISIBLE);
    }

    @Override
    public boolean isCustomViewShowing() {
        return mCustomView != null;
    }

    @Override
    public void showVoiceTitleBar(String title) {
        mTitleBar.setInVoiceMode(true);
        mTitleBar.setDisplayTitle(title);
        mFakeTitleBar.setInVoiceMode(true);
        mFakeTitleBar.setDisplayTitle(title);
    }

    @Override
    public void revertVoiceTitleBar(Tab tab) {
        mTitleBar.setInVoiceMode(false);
        String url = tab.getCurrentUrl();
        mTitleBar.setDisplayTitle(url);
        mFakeTitleBar.setInVoiceMode(false);
        mFakeTitleBar.setDisplayTitle(url);
    }

    // -------------------------------------------------------------------------

    @Override
    public void resetTitleAndRevertLockIcon(Tab tab) {
        tab.revertLockIcon();
        updateLockIconToLatest(tab);
        resetTitleIconAndProgress(tab);
    }

    /**
     * Resets the lock icon. This method is called when we start a new load and
     * know the url to be loaded.
     */
    private void resetLockIcon(Tab tab, String url) {
        // Save the lock-icon state (we revert to it if the load gets cancelled)
        tab.resetLockIcon(url);
        updateLockIconImage(Tab.LOCK_ICON_UNSECURE);
    }

    /**
     * Update the lock icon to correspond to our latest state.
     */
    private void updateLockIconToLatest(Tab t) {
        if (t != null) {
            updateLockIconImage(t.getLockIconType());
        }
    }

    /**
     * Reset the title, favicon, and progress.
     */
    private void resetTitleIconAndProgress(Tab tab) {
        WebView current = tab.getWebView();
        if (current == null) {
            return;
        }
        resetTitleAndIcon(current);
        int progress = current.getProgress();
        current.getWebChromeClient().onProgressChanged(current, progress);
    }

    @Override
    public void resetTitleAndIcon(Tab tab) {
        WebView current = tab.getWebView();
        if (current != null) {
            resetTitleAndIcon(current);
        }
    }

    // Reset the title and the icon based on the given item.
    private void resetTitleAndIcon(WebView view) {
        WebHistoryItem item = view.copyBackForwardList().getCurrentItem();
        Tab tab = mTabControl.getTabFromView(view);
        if (item != null) {
            setUrlTitle(tab, item.getUrl(), item.getTitle());
            setFavicon(tab, item.getFavicon());
        } else {
            setUrlTitle(tab, null, null);
            setFavicon(tab, null);
        }
    }

    /**
     * Updates the lock-icon image in the title-bar.
     */
    private void updateLockIconImage(int lockIconType) {
        Drawable d = null;
        if (lockIconType == Tab.LOCK_ICON_SECURE) {
            d = mSecLockIcon;
        } else if (lockIconType == Tab.LOCK_ICON_MIXED) {
            d = mMixLockIcon;
        }
        mTitleBar.setLock(d);
        mFakeTitleBar.setLock(d);
    }

    // active tabs page

    public void showActiveTabsPage() {
        mActiveTabsPage = new ActiveTabsPage(mActivity, mUiController);
        mTitleBar.setVisibility(View.GONE);
        hideFakeTitleBar();
        mContentView.addView(mActiveTabsPage, COVER_SCREEN_PARAMS);
        mActiveTabsPage.requestFocus();
    }

    /**
     * Remove the active tabs page.
     * @param needToAttach If true, the active tabs page did not attach a tab
     *                     to the content view, so we need to do that here.
     */
    public void removeActiveTabsPage() {
        mContentView.removeView(mActiveTabsPage);
        mTitleBar.setVisibility(View.VISIBLE);
        mActiveTabsPage = null;
    }

    // action mode callbacks

    @Override
    public void onActionModeStarted(ActionMode mode) {
        // hide the fake title bar when CAB is shown
        hideFakeTitleBar();
    }

    @Override
    public void onActionModeFinished(boolean inLoad) {
        if (inLoad) {
            // the titlebar was removed when the CAB was shown
            // if the page is loading, show it again
            showFakeTitleBar();
        }
    }

    // menu handling callbacks

    @Override
    public void onOptionsMenuOpened() {
        mOptionsMenuOpen = true;
        // options menu opened, show fake title bar
        showFakeTitleBar();
    }

    @Override
    public void onExtendedMenuOpened() {
        // Switching the menu to expanded view, so hide the
        // title bar.
        mExtendedMenuOpen = true;
        hideFakeTitleBar();
    }

    @Override
    public void onOptionsMenuClosed(boolean inLoad) {
        mOptionsMenuOpen = false;
        if (!inLoad) {
            hideFakeTitleBar();
        }
    }

    @Override
    public void onExtendedMenuClosed(boolean inLoad) {
        mExtendedMenuOpen = false;
        if (inLoad) {
            showFakeTitleBar();
        }
    }

    @Override
    public void onContextMenuCreated(Menu menu) {
        hideFakeTitleBar();
    }

    @Override
    public void onContextMenuClosed(Menu menu, boolean inLoad) {
        if (inLoad) {
            showFakeTitleBar();
        }
    }

    @Override
    public void onScroll(boolean titleVisible) {
        if (mTabBar != null) {
            mTabBar.onScroll(titleVisible);
        }
    }

    // error console

    @Override
    public void setShouldShowErrorConsole(Tab tab, boolean flag) {
        ErrorConsoleView errorConsole = tab.getErrorConsole(true);
        if (flag) {
            // Setting the show state of the console will cause it's the layout
            // to be inflated.
            if (errorConsole.numberOfErrors() > 0) {
                errorConsole.showConsole(ErrorConsoleView.SHOW_MINIMIZED);
            } else {
                errorConsole.showConsole(ErrorConsoleView.SHOW_NONE);
            }
            if (errorConsole.getParent() != null) {
                mErrorConsoleContainer.removeView(errorConsole);
            }
            // Now we can add it to the main view.
            mErrorConsoleContainer.addView(errorConsole,
                    new LinearLayout.LayoutParams(
                            ViewGroup.LayoutParams.MATCH_PARENT,
                            ViewGroup.LayoutParams.WRAP_CONTENT));
        } else {
            mErrorConsoleContainer.removeView(errorConsole);
        }
    }

    private void setStatusBarVisibility(boolean visible) {
        int flag = visible ? 0 : WindowManager.LayoutParams.FLAG_FULLSCREEN;
        mActivity.getWindow().setFlags(flag,
                WindowManager.LayoutParams.FLAG_FULLSCREEN);
    }

    @Override
    public void setUrlTitle(Tab tab, String url, String title) {
        if (TextUtils.isEmpty(title)) {
            if (TextUtils.isEmpty(url)) {
                title = mActivity.getResources()
                        .getString(R.string.title_bar_loading);
            } else {
                title = url;
            }
        }
        if (tab.isInVoiceSearchMode()) return;
        if (tab.inForeground()) {
            mTitleBar.setDisplayTitle(url);
            mFakeTitleBar.setDisplayTitle(url);
        }
        if (mXLargeScreenSize) {
            mTabBar.onUrlAndTitle(tab, url, title);
        }
    }

    // Set the favicon in the title bar.
    @Override
    public void setFavicon(Tab tab, Bitmap icon) {
        mTitleBar.setFavicon(icon);
        mFakeTitleBar.setFavicon(icon);
        if (mXLargeScreenSize) {
            mTabBar.onFavicon(tab, icon);
        }
    }
    @Override
    public boolean showsWeb() {
        return mCustomView == null && mActiveTabsPage == null
            && mComboView == null;
    }

    @Override
    public void onPrepareOptionsMenu(Menu menu) {
        if (!mXLargeScreenSize) {
            final MenuItem newtab = menu.findItem(R.id.new_tab_menu_id);
            newtab.setEnabled(mUiController.getTabControl().canCreateNewTab());
        }
    }

    // -------------------------------------------------------------------------
    // Helper function for WebChromeClient
    // -------------------------------------------------------------------------

    @Override
    public Bitmap getDefaultVideoPoster() {
        if (mDefaultVideoPoster == null) {
            mDefaultVideoPoster = BitmapFactory.decodeResource(
                    mActivity.getResources(), R.drawable.default_video_poster);
        }
        return mDefaultVideoPoster;
    }

    @Override
    public View getVideoLoadingProgressView() {
        if (mVideoProgressView == null) {
            LayoutInflater inflater = LayoutInflater.from(mActivity);
            mVideoProgressView = inflater.inflate(
                    R.layout.video_loading_progress, null);
        }
        return mVideoProgressView;
    }

}