src/com/android/browser/BrowserActivity.java

   1 /*
   2  * Copyright (C) 2006 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package com.android.browser;
  18
  19 import android.app.Activity;
  20 import android.app.AlertDialog;
  21 import android.app.ProgressDialog;
  22 import android.app.SearchManager;
  23 import android.content.ActivityNotFoundException;
  24 import android.content.BroadcastReceiver;
  25 import android.content.ComponentName;
  26 import android.content.ContentProvider;
  27 import android.content.ContentProviderClient;
  28 import android.content.ContentResolver;
  29 import android.content.ContentUris;
  30 import android.content.ContentValues;
  31 import android.content.Context;
  32 import android.content.DialogInterface;
  33 import android.content.Intent;
  34 import android.content.IntentFilter;
  35 import android.content.pm.PackageInfo;
  36 import android.content.pm.PackageManager;
  37 import android.content.pm.ResolveInfo;
  38 import android.content.res.Configuration;
  39 import android.content.res.Resources;
  40 import android.database.Cursor;
  41 import android.database.DatabaseUtils;
  42 import android.graphics.Bitmap;
  43 import android.graphics.BitmapFactory;
  44 import android.graphics.Canvas;
  45 import android.graphics.Picture;
  46 import android.graphics.PixelFormat;
  47 import android.graphics.Rect;
  48 import android.graphics.drawable.Drawable;
  49 import android.net.ConnectivityManager;
  50 import android.net.NetworkInfo;
  51 import android.net.Uri;
  52 import android.net.WebAddress;
  53 import android.net.http.SslCertificate;
  54 import android.net.http.SslError;
  55 import android.os.AsyncTask;
  56 import android.os.Bundle;
  57 import android.os.Debug;
  58 import android.os.Environment;
  59 import android.os.Handler;
  60 import android.os.Message;
  61 import android.os.PowerManager;
  62 import android.os.Process;
  63 import android.os.ServiceManager;
  64 import android.os.SystemClock;
  65 import android.provider.Browser;
  66 import android.provider.ContactsContract;
  67 import android.provider.ContactsContract.Intents.Insert;
  68 import android.provider.Downloads;
  69 import android.provider.MediaStore;
  70 import android.speech.RecognizerResultsIntent;
  71 import android.text.IClipboard;
  72 import android.text.TextUtils;
  73 import android.text.format.DateFormat;
  74 import android.util.AttributeSet;
  75 import android.util.Log;
  76 import android.util.Patterns;
  77 import android.view.ContextMenu;
  78 import android.view.Gravity;
  79 import android.view.KeyEvent;
  80 import android.view.LayoutInflater;
  81 import android.view.Menu;
  82 import android.view.MenuInflater;
  83 import android.view.MenuItem;
  84 import android.view.View;
  85 import android.view.ViewGroup;
  86 import android.view.Window;
  87 import android.view.WindowManager;
  88 import android.view.ContextMenu.ContextMenuInfo;
  89 import android.view.MenuItem.OnMenuItemClickListener;
  90 import android.webkit.CookieManager;
  91 import android.webkit.CookieSyncManager;
  92 import android.webkit.DownloadListener;
  93 import android.webkit.HttpAuthHandler;
  94 import android.webkit.PluginManager;
  95 import android.webkit.SslErrorHandler;
  96 import android.webkit.URLUtil;
  97 import android.webkit.ValueCallback;
  98 import android.webkit.WebChromeClient;
  99 import android.webkit.WebHistoryItem;
 100 import android.webkit.WebIconDatabase;
 101 import android.webkit.WebView;
 102 import android.widget.EditText;
 103 import android.widget.FrameLayout;
 104 import android.widget.LinearLayout;
 105 import android.widget.TextView;
 106 import android.widget.Toast;
 107 import android.accounts.Account;
 108 import android.accounts.AccountManager;
 109 import android.accounts.AccountManagerFuture;
 110 import android.accounts.AuthenticatorException;
 111 import android.accounts.OperationCanceledException;
 112 import android.accounts.AccountManagerCallback;
 113
 114 import com.android.common.Search;
 115 import com.android.common.speech.LoggingEvents;
 116
 117 import java.io.ByteArrayOutputStream;
 118 import java.io.File;
 119 import java.io.IOException;
 120 import java.io.InputStream;
 121 import java.net.MalformedURLException;
 122 import java.net.URI;
 123 import java.net.URISyntaxException;
 124 import java.net.URL;
 125 import java.net.URLEncoder;
 126 import java.text.ParseException;
 127 import java.util.Date;
 128 import java.util.HashMap;
 129 import java.util.HashSet;
 130 import java.util.Iterator;
 131 import java.util.List;
 132 import java.util.Map;
 133 import java.util.Set;
 134 import java.util.regex.Matcher;
 135 import java.util.regex.Pattern;
 136
 137 public class BrowserActivity extends Activity
 138     implements View.OnCreateContextMenuListener, DownloadListener {
 139
 140     /* Define some aliases to make these debugging flags easier to refer to.
 141      * This file imports android.provider.Browser, so we can't just refer to "Browser.DEBUG".
 142      */
 143     private final static boolean DEBUG = com.android.browser.Browser.DEBUG;
 144     private final static boolean LOGV_ENABLED = com.android.browser.Browser.LOGV_ENABLED;
 145     private final static boolean LOGD_ENABLED = com.android.browser.Browser.LOGD_ENABLED;
 146
 147     // These are single-character shortcuts for searching popular sources.
 148     private static final int SHORTCUT_INVALID = 0;
 149     private static final int SHORTCUT_GOOGLE_SEARCH = 1;
 150     private static final int SHORTCUT_WIKIPEDIA_SEARCH = 2;
 151     private static final int SHORTCUT_DICTIONARY_SEARCH = 3;
 152     private static final int SHORTCUT_GOOGLE_MOBILE_LOCAL_SEARCH = 4;
 153
 154     private static class ClearThumbnails extends AsyncTask<File, Void, Void> {
 155         @Override
 156         public Void doInBackground(File... files) {
 157             if (files != null) {
 158                 for (File f : files) {
 159                     if (!f.delete()) {
 160                       Log.e(LOGTAG, f.getPath() + " was not deleted");
 161                     }
 162                 }
 163             }
 164             return null;
 165         }
 166     }
 167
 168     /**
 169      * This layout holds everything you see below the status bar, including the
 170      * error console, the custom view container, and the webviews.
 171      */
 172     private FrameLayout mBrowserFrameLayout;
 173
 174     @Override
 175     public void onCreate(Bundle icicle) {
 176         if (LOGV_ENABLED) {
 177             Log.v(LOGTAG, this + " onStart");
 178         }
 179         super.onCreate(icicle);
 180         // test the browser in OpenGL
 181         // requestWindowFeature(Window.FEATURE_OPENGL);
 182
 183         // enable this to test the browser in 32bit
 184         if (false) {
 185             getWindow().setFormat(PixelFormat.RGBX_8888);
 186             BitmapFactory.setDefaultConfig(Bitmap.Config.ARGB_8888);
 187         }
 188
 189         setDefaultKeyMode(DEFAULT_KEYS_SEARCH_LOCAL);
 190
 191         mResolver = getContentResolver();
 192
 193         // If this was a web search request, pass it on to the default web
 194         // search provider and finish this activity.
 195         if (handleWebSearchIntent(getIntent())) {
 196             finish();
 197             return;
 198         }
 199
 200         mSecLockIcon = Resources.getSystem().getDrawable(
 201                 android.R.drawable.ic_secure);
 202         mMixLockIcon = Resources.getSystem().getDrawable(
 203                 android.R.drawable.ic_partial_secure);
 204
 205         FrameLayout frameLayout = (FrameLayout) getWindow().getDecorView()
 206                 .findViewById(com.android.internal.R.id.content);
 207         mBrowserFrameLayout = (FrameLayout) LayoutInflater.from(this)
 208                 .inflate(R.layout.custom_screen, null);
 209         mContentView = (FrameLayout) mBrowserFrameLayout.findViewById(
 210                 R.id.main_content);
 211         mErrorConsoleContainer = (LinearLayout) mBrowserFrameLayout
 212                 .findViewById(R.id.error_console);
 213         mCustomViewContainer = (FrameLayout) mBrowserFrameLayout
 214                 .findViewById(R.id.fullscreen_custom_content);
 215         frameLayout.addView(mBrowserFrameLayout, COVER_SCREEN_PARAMS);
 216         mTitleBar = new TitleBar(this);
 217         // mTitleBar will be always shown in the fully loaded mode
 218         mTitleBar.setProgress(100);
 219         mFakeTitleBar = new TitleBar(this);
 220
 221         // Create the tab control and our initial tab
 222         mTabControl = new TabControl(this);
 223
 224         // Open the icon database and retain all the bookmark urls for favicons
 225         retainIconsOnStartup();
 226
 227         // Keep a settings instance handy.
 228         mSettings = BrowserSettings.getInstance();
 229         mSettings.setTabControl(mTabControl);
 230
 231         PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
 232         mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "Browser");
 233
 234         // Find out if the network is currently up.
 235         ConnectivityManager cm = (ConnectivityManager) getSystemService(
 236                 Context.CONNECTIVITY_SERVICE);
 237         NetworkInfo info = cm.getActiveNetworkInfo();
 238         if (info != null) {
 239             mIsNetworkUp = info.isAvailable();
 240         }
 241
 242         /* enables registration for changes in network status from
 243            http stack */
 244         mNetworkStateChangedFilter = new IntentFilter();
 245         mNetworkStateChangedFilter.addAction(
 246                 ConnectivityManager.CONNECTIVITY_ACTION);
 247         mNetworkStateIntentReceiver = new BroadcastReceiver() {
 248                 @Override
 249                 public void onReceive(Context context, Intent intent) {
 250                     if (intent.getAction().equals(
 251                             ConnectivityManager.CONNECTIVITY_ACTION)) {
 252
 253                         NetworkInfo info = intent.getParcelableExtra(
 254                                 ConnectivityManager.EXTRA_NETWORK_INFO);
 255                         String typeName = info.getTypeName();
 256                         String subtypeName = info.getSubtypeName();
 257                         sendNetworkType(typeName.toLowerCase(),
 258                                 (subtypeName != null ? subtypeName.toLowerCase() : ""));
 259
 260                         onNetworkToggle(info.isAvailable());
 261                     }
 262                 }
 263             };
 264
 265         IntentFilter filter = new IntentFilter(Intent.ACTION_PACKAGE_ADDED);
 266         filter.addAction(Intent.ACTION_PACKAGE_REMOVED);
 267         filter.addDataScheme("package");
 268         mPackageInstallationReceiver = new BroadcastReceiver() {
 269             @Override
 270             public void onReceive(Context context, Intent intent) {
 271                 final String action = intent.getAction();
 272                 final String packageName = intent.getData()
 273                         .getSchemeSpecificPart();
 274                 final boolean replacing = intent.getBooleanExtra(
 275                         Intent.EXTRA_REPLACING, false);
 276                 if (Intent.ACTION_PACKAGE_REMOVED.equals(action) && replacing) {
 277                     // if it is replacing, refreshPlugins() when adding
 278                     return;
 279                 }
 280
 281                 if (sGoogleApps.contains(packageName)) {
 282                     BrowserActivity.this.packageChanged(packageName,
 283                             Intent.ACTION_PACKAGE_ADDED.equals(action));
 284                 }
 285
 286                 PackageManager pm = BrowserActivity.this.getPackageManager();
 287                 PackageInfo pkgInfo = null;
 288                 try {
 289                     pkgInfo = pm.getPackageInfo(packageName,
 290                             PackageManager.GET_PERMISSIONS);
 291                 } catch (PackageManager.NameNotFoundException e) {
 292                     return;
 293                 }
 294                 if (pkgInfo != null) {
 295                     String permissions[] = pkgInfo.requestedPermissions;
 296                     if (permissions == null) {
 297                         return;
 298                     }
 299                     boolean permissionOk = false;
 300                     for (String permit : permissions) {
 301                         if (PluginManager.PLUGIN_PERMISSION.equals(permit)) {
 302                             permissionOk = true;
 303                             break;
 304                         }
 305                     }
 306                     if (permissionOk) {
 307                         PluginManager.getInstance(BrowserActivity.this)
 308                                 .refreshPlugins(
 309                                         Intent.ACTION_PACKAGE_ADDED
 310                                                 .equals(action));
 311                     }
 312                 }
 313             }
 314         };
 315         registerReceiver(mPackageInstallationReceiver, filter);
 316
 317         if (!mTabControl.restoreState(icicle)) {
 318             // clear up the thumbnail directory if we can't restore the state as
 319             // none of the files in the directory are referenced any more.
 320             new ClearThumbnails().execute(
 321                     mTabControl.getThumbnailDir().listFiles());
 322             // there is no quit on Android. But if we can't restore the state,
 323             // we can treat it as a new Browser, remove the old session cookies.
 324             CookieManager.getInstance().removeSessionCookie();
 325             final Intent intent = getIntent();
 326             final Bundle extra = intent.getExtras();
 327             // Create an initial tab.
 328             // If the intent is ACTION_VIEW and data is not null, the Browser is
 329             // invoked to view the content by another application. In this case,
 330             // the tab will be close when exit.
 331             UrlData urlData = getUrlDataFromIntent(intent);
 332
 333             String action = intent.getAction();
 334             final Tab t = mTabControl.createNewTab(
 335                     (Intent.ACTION_VIEW.equals(action) &&
 336                     intent.getData() != null)
 337                     || RecognizerResultsIntent.ACTION_VOICE_SEARCH_RESULTS
 338                     .equals(action),
 339                     intent.getStringExtra(Browser.EXTRA_APPLICATION_ID), urlData.mUrl);
 340             mTabControl.setCurrentTab(t);
 341             attachTabToContentView(t);
 342             WebView webView = t.getWebView();
 343             if (extra != null) {
 344                 int scale = extra.getInt(Browser.INITIAL_ZOOM_LEVEL, 0);
 345                 if (scale > 0 && scale <= 1000) {
 346                     webView.setInitialScale(scale);
 347                 }
 348             }
 349
 350             if (urlData.isEmpty()) {
 351                 loadUrl(webView, mSettings.getHomePage());
 352             } else {
 353                 loadUrlDataIn(t, urlData);
 354             }
 355         } else {
 356             // TabControl.restoreState() will create a new tab even if
 357             // restoring the state fails.
 358             attachTabToContentView(mTabControl.getCurrentTab());
 359         }
 360
 361         // Read JavaScript flags if it exists.
 362         String jsFlags = mSettings.getJsFlags();
 363         if (jsFlags.trim().length() != 0) {
 364             mTabControl.getCurrentWebView().setJsFlags(jsFlags);
 365         }
 366         // Work out which packages are installed on the system.
 367         getInstalledPackages();
 368
 369         // Start watching the default geolocation permissions
 370         mSystemAllowGeolocationOrigins
 371                 = new SystemAllowGeolocationOrigins(getApplicationContext());
 372         mSystemAllowGeolocationOrigins.start();
 373     }
 374
 375     /**
 376      * Feed the previously stored results strings to the BrowserProvider so that
 377      * the SearchDialog will show them instead of the standard searches.
 378      * @param result String to show on the editable line of the SearchDialog.
 379      */
 380     /* package */ void showVoiceSearchResults(String result) {
 381         ContentProviderClient client = mResolver.acquireContentProviderClient(
 382                 Browser.BOOKMARKS_URI);
 383         ContentProvider prov = client.getLocalContentProvider();
 384         BrowserProvider bp = (BrowserProvider) prov;
 385         bp.setQueryResults(mTabControl.getCurrentTab().getVoiceSearchResults());
 386         client.release();
 387
 388         Bundle bundle = createGoogleSearchSourceBundle(
 389                 GOOGLE_SEARCH_SOURCE_SEARCHKEY);
 390         bundle.putBoolean(SearchManager.CONTEXT_IS_VOICE, true);
 391         startSearch(result, false, bundle, false);
 392     }
 393
 394     @Override
 395     protected void onNewIntent(Intent intent) {
 396         Tab current = mTabControl.getCurrentTab();
 397         // When a tab is closed on exit, the current tab index is set to -1.
 398         // Reset before proceed as Browser requires the current tab to be set.
 399         if (current == null) {
 400             // Try to reset the tab in case the index was incorrect.
 401             current = mTabControl.getTab(0);
 402             if (current == null) {
 403                 // No tabs at all so just ignore this intent.
 404                 return;
 405             }
 406             mTabControl.setCurrentTab(current);
 407             attachTabToContentView(current);
 408             resetTitleAndIcon(current.getWebView());
 409         }
 410         final String action = intent.getAction();
 411         final int flags = intent.getFlags();
 412         if (Intent.ACTION_MAIN.equals(action) ||
 413                 (flags & Intent.FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY) != 0) {
 414             // just resume the browser
 415             return;
 416         }
 417         // In case the SearchDialog is open.
 418         ((SearchManager) getSystemService(Context.SEARCH_SERVICE))
 419                 .stopSearch();
 420         boolean activateVoiceSearch = RecognizerResultsIntent
 421                 .ACTION_VOICE_SEARCH_RESULTS.equals(action);
 422         if (Intent.ACTION_VIEW.equals(action)
 423                 || Intent.ACTION_SEARCH.equals(action)
 424                 || MediaStore.INTENT_ACTION_MEDIA_SEARCH.equals(action)
 425                 || Intent.ACTION_WEB_SEARCH.equals(action)
 426                 || activateVoiceSearch) {
 427             if (current.isInVoiceSearchMode()) {
 428                 String title = current.getVoiceDisplayTitle();
 429                 if (title != null && title.equals(intent.getStringExtra(
 430                         SearchManager.QUERY))) {
 431                     // The user submitted the same search as the last voice
 432                     // search, so do nothing.
 433                     return;
 434                 }
 435                 if (Intent.ACTION_SEARCH.equals(action)
 436                         && current.voiceSearchSourceIsGoogle()) {
 437                     Intent logIntent = new Intent(
 438                             LoggingEvents.ACTION_LOG_EVENT);
 439                     logIntent.putExtra(LoggingEvents.EXTRA_EVENT,
 440                             LoggingEvents.VoiceSearch.QUERY_UPDATED);
 441                     logIntent.putExtra(
 442                             LoggingEvents.VoiceSearch.EXTRA_QUERY_UPDATED_VALUE,
 443                             intent.getDataString());
 444                     sendBroadcast(logIntent);
 445                     // Note, onPageStarted will revert the voice title bar
 446                     // When http://b/issue?id=2379215 is fixed, we should update
 447                     // the title bar here.
 448                 }
 449             }
 450             // If this was a search request (e.g. search query directly typed into the address bar),
 451             // pass it on to the default web search provider.
 452             if (handleWebSearchIntent(intent)) {
 453                 return;
 454             }
 455
 456             UrlData urlData = getUrlDataFromIntent(intent);
 457             if (urlData.isEmpty()) {
 458                 urlData = new UrlData(mSettings.getHomePage());
 459             }
 460
 461             final String appId = intent
 462                     .getStringExtra(Browser.EXTRA_APPLICATION_ID);
 463             if ((Intent.ACTION_VIEW.equals(action) || activateVoiceSearch)
 464                     && !getPackageName().equals(appId)
 465                     && (flags & Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT) != 0) {
 466                 Tab appTab = mTabControl.getTabFromId(appId);
 467                 if (appTab != null) {
 468                     Log.i(LOGTAG, "Reusing tab for " + appId);
 469                     // Dismiss the subwindow if applicable.
 470                     dismissSubWindow(appTab);
 471                     // Since we might kill the WebView, remove it from the
 472                     // content view first.
 473                     removeTabFromContentView(appTab);
 474                     // Recreate the main WebView after destroying the old one.
 475                     // If the WebView has the same original url and is on that
 476                     // page, it can be reused.
 477                     boolean needsLoad =
 478                             mTabControl.recreateWebView(appTab, urlData);
 479
 480                     if (current != appTab) {
 481                         switchToTab(mTabControl.getTabIndex(appTab));
 482                         if (needsLoad) {
 483                             loadUrlDataIn(appTab, urlData);
 484                         }
 485                     } else {
 486                         // If the tab was the current tab, we have to attach
 487                         // it to the view system again.
 488                         attachTabToContentView(appTab);
 489                         if (needsLoad) {
 490                             loadUrlDataIn(appTab, urlData);
 491                         }
 492                     }
 493                     return;
 494                 } else {
 495                     // No matching application tab, try to find a regular tab
 496                     // with a matching url.
 497                     appTab = mTabControl.findUnusedTabWithUrl(urlData.mUrl);
 498                     if (appTab != null) {
 499                         if (current != appTab) {
 500                             switchToTab(mTabControl.getTabIndex(appTab));
 501                         }
 502                         // Otherwise, we are already viewing the correct tab.
 503                     } else {
 504                         // if FLAG_ACTIVITY_BROUGHT_TO_FRONT flag is on, the url
 505                         // will be opened in a new tab unless we have reached
 506                         // MAX_TABS. Then the url will be opened in the current
 507                         // tab. If a new tab is created, it will have "true" for
 508                         // exit on close.
 509                         openTabAndShow(urlData, true, appId);
 510                     }
 511                 }
 512             } else {
 513                 if (!urlData.isEmpty()
 514                         && urlData.mUrl.startsWith("about:debug")) {
 515                     if ("about:debug.dom".equals(urlData.mUrl)) {
 516                         current.getWebView().dumpDomTree(false);
 517                     } else if ("about:debug.dom.file".equals(urlData.mUrl)) {
 518                         current.getWebView().dumpDomTree(true);
 519                     } else if ("about:debug.render".equals(urlData.mUrl)) {
 520                         current.getWebView().dumpRenderTree(false);
 521                     } else if ("about:debug.render.file".equals(urlData.mUrl)) {
 522                         current.getWebView().dumpRenderTree(true);
 523                     } else if ("about:debug.display".equals(urlData.mUrl)) {
 524                         current.getWebView().dumpDisplayTree();
 525                     } else if (urlData.mUrl.startsWith("about:debug.drag")) {
 526                         int index = urlData.mUrl.codePointAt(16) - '0';
 527                         if (index <= 0 || index > 9) {
 528                             current.getWebView().setDragTracker(null);
 529                         } else {
 530                             current.getWebView().setDragTracker(new MeshTracker(index));
 531                         }
 532                     } else {
 533                         mSettings.toggleDebugSettings();
 534                     }
 535                     return;
 536                 }
 537                 // Get rid of the subwindow if it exists
 538                 dismissSubWindow(current);
 539                 loadUrlDataIn(current, urlData);
 540             }
 541         }
 542     }
 543
 544     private int parseUrlShortcut(String url) {
 545         if (url == null) return SHORTCUT_INVALID;
 546
 547         // FIXME: quick search, need to be customized by setting
 548         if (url.length() > 2 && url.charAt(1) == ' ') {
 549             switch (url.charAt(0)) {
 550             case 'g': return SHORTCUT_GOOGLE_SEARCH;
 551             case 'w': return SHORTCUT_WIKIPEDIA_SEARCH;
 552             case 'd': return SHORTCUT_DICTIONARY_SEARCH;
 553             case 'l': return SHORTCUT_GOOGLE_MOBILE_LOCAL_SEARCH;
 554             }
 555         }
 556         return SHORTCUT_INVALID;
 557     }
 558
 559     /**
 560      * Launches the default web search activity with the query parameters if the given intent's data
 561      * are identified as plain search terms and not URLs/shortcuts.
 562      * @return true if the intent was handled and web search activity was launched, false if not.
 563      */
 564     private boolean handleWebSearchIntent(Intent intent) {
 565         if (intent == null) return false;
 566
 567         String url = null;
 568         final String action = intent.getAction();
 569         if (RecognizerResultsIntent.ACTION_VOICE_SEARCH_RESULTS.equals(
 570                 action)) {
 571             return false;
 572         }
 573         if (Intent.ACTION_VIEW.equals(action)) {
 574             Uri data = intent.getData();
 575             if (data != null) url = data.toString();
 576         } else if (Intent.ACTION_SEARCH.equals(action)
 577                 || MediaStore.INTENT_ACTION_MEDIA_SEARCH.equals(action)
 578                 || Intent.ACTION_WEB_SEARCH.equals(action)) {
 579             url = intent.getStringExtra(SearchManager.QUERY);
 580         }
 581         return handleWebSearchRequest(url, intent.getBundleExtra(SearchManager.APP_DATA),
 582                 intent.getStringExtra(SearchManager.EXTRA_DATA_KEY));
 583     }
 584
 585     /**
 586      * Launches the default web search activity with the query parameters if the given url string
 587      * was identified as plain search terms and not URL/shortcut.
 588      * @return true if the request was handled and web search activity was launched, false if not.
 589      */
 590     private boolean handleWebSearchRequest(String inUrl, Bundle appData, String extraData) {
 591         if (inUrl == null) return false;
 592
 593         // In general, we shouldn't modify URL from Intent.
 594         // But currently, we get the user-typed URL from search box as well.
 595         String url = fixUrl(inUrl).trim();
 596
 597         // URLs and site specific search shortcuts are handled by the regular flow of control, so
 598         // return early.
 599         if (Patterns.WEB_URL.matcher(url).matches()
 600                 || ACCEPTED_URI_SCHEMA.matcher(url).matches()
 601                 || parseUrlShortcut(url) != SHORTCUT_INVALID) {
 602             return false;
 603         }
 604
 605         final ContentResolver cr = mResolver;
 606         final String newUrl = url;
 607         new AsyncTask<Void, Void, Void>() {
 608             protected Void doInBackground(Void... unused) {
 609                 Browser.updateVisitedHistory(cr, newUrl, false);
 610                 Browser.addSearchUrl(cr, newUrl);
 611                 return null;
 612             }
 613         }.execute();
 614
 615         Intent intent = new Intent(Intent.ACTION_WEB_SEARCH);
 616         intent.addCategory(Intent.CATEGORY_DEFAULT);
 617         intent.putExtra(SearchManager.QUERY, url);
 618         if (appData != null) {
 619             intent.putExtra(SearchManager.APP_DATA, appData);
 620         }
 621         if (extraData != null) {
 622             intent.putExtra(SearchManager.EXTRA_DATA_KEY, extraData);
 623         }
 624         intent.putExtra(Browser.EXTRA_APPLICATION_ID, getPackageName());
 625         startActivity(intent);
 626
 627         return true;
 628     }
 629
 630     private UrlData getUrlDataFromIntent(Intent intent) {
 631         String url = "";
 632         Map<String, String> headers = null;
 633         if (intent != null) {
 634             final String action = intent.getAction();
 635             if (Intent.ACTION_VIEW.equals(action)) {
 636                 url = smartUrlFilter(intent.getData());
 637                 if (url != null && url.startsWith("content:")) {
 638                     /* Append mimetype so webview knows how to display */
 639                     String mimeType = intent.resolveType(getContentResolver());
 640                     if (mimeType != null) {
 641                         url += "?" + mimeType;
 642                     }
 643                 }
 644                 if (url != null && url.startsWith("http")) {
 645                     final Bundle pairs = intent
 646                             .getBundleExtra(Browser.EXTRA_HEADERS);
 647                     if (pairs != null && !pairs.isEmpty()) {
 648                         Iterator<String> iter = pairs.keySet().iterator();
 649                         headers = new HashMap<String, String>();
 650                         while (iter.hasNext()) {
 651                             String key = iter.next();
 652                             headers.put(key, pairs.getString(key));
 653                         }
 654                     }
 655                 }
 656             } else if (Intent.ACTION_SEARCH.equals(action)
 657                     || MediaStore.INTENT_ACTION_MEDIA_SEARCH.equals(action)
 658                     || Intent.ACTION_WEB_SEARCH.equals(action)) {
 659                 url = intent.getStringExtra(SearchManager.QUERY);
 660                 if (url != null) {
 661                     mLastEnteredUrl = url;
 662                     // In general, we shouldn't modify URL from Intent.
 663                     // But currently, we get the user-typed URL from search box as well.
 664                     url = fixUrl(url);
 665                     url = smartUrlFilter(url);
 666                     final ContentResolver cr = mResolver;
 667                     final String newUrl = url;
 668                     new AsyncTask<Void, Void, Void>() {
 669                         protected Void doInBackground(Void... unused) {
 670                             Browser.updateVisitedHistory(cr, newUrl, false);
 671                             return null;
 672                         }
 673                     }.execute();
 674                     String searchSource = "&source=android-" + GOOGLE_SEARCH_SOURCE_SUGGEST + "&";
 675                     if (url.contains(searchSource)) {
 676                         String source = null;
 677                         final Bundle appData = intent.getBundleExtra(SearchManager.APP_DATA);
 678                         if (appData != null) {
 679                             source = appData.getString(Search.SOURCE);
 680                         }
 681                         if (TextUtils.isEmpty(source)) {
 682                             source = GOOGLE_SEARCH_SOURCE_UNKNOWN;
 683                         }
 684                         url = url.replace(searchSource, "&source=android-"+source+"&");
 685                     }
 686                 }
 687             }
 688         }
 689         return new UrlData(url, headers, intent);
 690     }
 691     /* package */ void showVoiceTitleBar(String title) {
 692         mTitleBar.setInVoiceMode(true);
 693         mFakeTitleBar.setInVoiceMode(true);
 694
 695         mTitleBar.setDisplayTitle(title);
 696         mFakeTitleBar.setDisplayTitle(title);
 697     }
 698     /* package */ void revertVoiceTitleBar() {
 699         mTitleBar.setInVoiceMode(false);
 700         mFakeTitleBar.setInVoiceMode(false);
 701
 702         mTitleBar.setDisplayTitle(mUrl);
 703         mFakeTitleBar.setDisplayTitle(mUrl);
 704     }
 705     /* package */ static String fixUrl(String inUrl) {
 706         // FIXME: Converting the url to lower case
 707         // duplicates functionality in smartUrlFilter().
 708         // However, changing all current callers of fixUrl to
 709         // call smartUrlFilter in addition may have unwanted
 710         // consequences, and is deferred for now.
 711         int colon = inUrl.indexOf(':');
 712         boolean allLower = true;
 713         for (int index = 0; index < colon; index++) {
 714             char ch = inUrl.charAt(index);
 715             if (!Character.isLetter(ch)) {
 716                 break;
 717             }
 718             allLower &= Character.isLowerCase(ch);
 719             if (index == colon - 1 && !allLower) {
 720                 inUrl = inUrl.substring(0, colon).toLowerCase()
 721                         + inUrl.substring(colon);
 722             }
 723         }
 724         if (inUrl.startsWith("http://") || inUrl.startsWith("https://"))
 725             return inUrl;
 726         if (inUrl.startsWith("http:") ||
 727                 inUrl.startsWith("https:")) {
 728             if (inUrl.startsWith("http:/") || inUrl.startsWith("https:/")) {
 729                 inUrl = inUrl.replaceFirst("/", "//");
 730             } else inUrl = inUrl.replaceFirst(":", "://");
 731         }
 732         return inUrl;
 733     }
 734
 735     @Override
 736     protected void onResume() {
 737         super.onResume();
 738         if (LOGV_ENABLED) {
 739             Log.v(LOGTAG, "BrowserActivity.onResume: this=" + this);
 740         }
 741
 742         if (!mActivityInPause) {
 743             Log.e(LOGTAG, "BrowserActivity is already resumed.");
 744             return;
 745         }
 746
 747         mTabControl.resumeCurrentTab();
 748         mActivityInPause = false;
 749         resumeWebViewTimers();
 750
 751         if (mWakeLock.isHeld()) {
 752             mHandler.removeMessages(RELEASE_WAKELOCK);
 753             mWakeLock.release();
 754         }
 755
 756         registerReceiver(mNetworkStateIntentReceiver,
 757                          mNetworkStateChangedFilter);
 758         WebView.enablePlatformNotifications();
 759     }
 760
 761     /**
 762      * Since the actual title bar is embedded in the WebView, and removing it
 763      * would change its appearance, use a different TitleBar to show overlayed
 764      * at the top of the screen, when the menu is open or the page is loading.
 765      */
 766     private TitleBar mFakeTitleBar;
 767
 768     /**
 769      * Keeps track of whether the options menu is open.  This is important in
 770      * determining whether to show or hide the title bar overlay.
 771      */
 772     private boolean mOptionsMenuOpen;
 773
 774     /**
 775      * Only meaningful when mOptionsMenuOpen is true.  This variable keeps track
 776      * of whether the configuration has changed.  The first onMenuOpened call
 777      * after a configuration change is simply a reopening of the same menu
 778      * (i.e. mIconView did not change).
 779      */
 780     private boolean mConfigChanged;
 781
 782     /**
 783      * Whether or not the options menu is in its smaller, icon menu form.  When
 784      * true, we want the title bar overlay to be up.  When false, we do not.
 785      * Only meaningful if mOptionsMenuOpen is true.
 786      */
 787     private boolean mIconView;
 788
 789     @Override
 790     public boolean onMenuOpened(int featureId, Menu menu) {
 791         if (Window.FEATURE_OPTIONS_PANEL == featureId) {
 792             if (mOptionsMenuOpen) {
 793                 if (mConfigChanged) {
 794                     // We do not need to make any changes to the state of the
 795                     // title bar, since the only thing that happened was a
 796                     // change in orientation
 797                     mConfigChanged = false;
 798                 } else {
 799                     if (mIconView) {
 800                         // Switching the menu to expanded view, so hide the
 801                         // title bar.
 802                         hideFakeTitleBar();
 803                         mIconView = false;
 804                     } else {
 805                         // Switching the menu back to icon view, so show the
 806                         // title bar once again.
 807                         showFakeTitleBar();
 808                         mIconView = true;
 809                     }
 810                 }
 811             } else {
 812                 // The options menu is closed, so open it, and show the title
 813                 showFakeTitleBar();
 814                 mOptionsMenuOpen = true;
 815                 mConfigChanged = false;
 816                 mIconView = true;
 817             }
 818         }
 819         return true;
 820     }
 821
 822     private void showFakeTitleBar() {
 823         if (mFakeTitleBar.getParent() == null && mActiveTabsPage == null
 824                 && !mActivityInPause) {
 825             WebView mainView = mTabControl.getCurrentWebView();
 826             // if there is no current WebView, don't show the faked title bar;
 827             if (mainView == null) {
 828                 return;
 829             }
 830
 831             WindowManager manager
 832                     = (WindowManager) getSystemService(Context.WINDOW_SERVICE);
 833
 834             // Add the title bar to the window manager so it can receive touches
 835             // while the menu is up
 836             WindowManager.LayoutParams params
 837                     = new WindowManager.LayoutParams(
 838                     ViewGroup.LayoutParams.MATCH_PARENT,
 839                     ViewGroup.LayoutParams.WRAP_CONTENT,
 840                     WindowManager.LayoutParams.TYPE_APPLICATION,
 841                     WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE,
 842                     PixelFormat.TRANSLUCENT);
 843             params.gravity = Gravity.TOP;
 844             boolean atTop = mainView.getScrollY() == 0;
 845             params.windowAnimations = atTop ? 0 : R.style.TitleBar;
 846             manager.addView(mFakeTitleBar, params);
 847         }
 848     }
 849
 850     @Override
 851     public void onOptionsMenuClosed(Menu menu) {
 852         mOptionsMenuOpen = false;
 853         if (!mInLoad) {
 854             hideFakeTitleBar();
 855         } else if (!mIconView) {
 856             // The page is currently loading, and we are in expanded mode, so
 857             // we were not showing the menu.  Show it once again.  It will be
 858             // removed when the page finishes.
 859             showFakeTitleBar();
 860         }
 861     }
 862
 863     private void hideFakeTitleBar() {
 864         if (mFakeTitleBar.getParent() == null) return;
 865         WindowManager.LayoutParams params = (WindowManager.LayoutParams)
 866                 mFakeTitleBar.getLayoutParams();
 867         WebView mainView = mTabControl.getCurrentWebView();
 868         // Although we decided whether or not to animate based on the current
 869         // scroll position, the scroll position may have changed since the
 870         // fake title bar was displayed.  Make sure it has the appropriate
 871         // animation/lack thereof before removing.
 872         params.windowAnimations = mainView != null && mainView.getScrollY() == 0
 873                 ? 0 : R.style.TitleBar;
 874         WindowManager manager
 875                     = (WindowManager) getSystemService(Context.WINDOW_SERVICE);
 876         manager.updateViewLayout(mFakeTitleBar, params);
 877         manager.removeView(mFakeTitleBar);
 878     }
 879
 880     /**
 881      * Special method for the fake title bar to call when displaying its context
 882      * menu, since it is in its own Window, and its parent does not show a
 883      * context menu.
 884      */
 885     /* package */ void showTitleBarContextMenu() {
 886         if (null == mTitleBar.getParent()) {
 887             return;
 888         }
 889         openContextMenu(mTitleBar);
 890     }
 891
 892     @Override
 893     public void onContextMenuClosed(Menu menu) {
 894         super.onContextMenuClosed(menu);
 895         if (mInLoad) {
 896             showFakeTitleBar();
 897         }
 898     }
 899
 900     /**
 901      *  onSaveInstanceState(Bundle map)
 902      *  onSaveInstanceState is called right before onStop(). The map contains
 903      *  the saved state.
 904      */
 905     @Override
 906     protected void onSaveInstanceState(Bundle outState) {
 907         if (LOGV_ENABLED) {
 908             Log.v(LOGTAG, "BrowserActivity.onSaveInstanceState: this=" + this);
 909         }
 910         // the default implementation requires each view to have an id. As the
 911         // browser handles the state itself and it doesn't use id for the views,
 912         // don't call the default implementation. Otherwise it will trigger the
 913         // warning like this, "couldn't save which view has focus because the
 914         // focused view XXX has no id".
 915
 916         // Save all the tabs
 917         mTabControl.saveState(outState);
 918     }
 919
 920     @Override
 921     protected void onPause() {
 922         super.onPause();
 923
 924         if (mActivityInPause) {
 925             Log.e(LOGTAG, "BrowserActivity is already paused.");
 926             return;
 927         }
 928
 929         mTabControl.pauseCurrentTab();
 930         mActivityInPause = true;
 931         if (mTabControl.getCurrentIndex() >= 0 && !pauseWebViewTimers()) {
 932             mWakeLock.acquire();
 933             mHandler.sendMessageDelayed(mHandler
 934                     .obtainMessage(RELEASE_WAKELOCK), WAKELOCK_TIMEOUT);
 935         }
 936
 937         // FIXME: This removes the active tabs page and resets the menu to
 938         // MAIN_MENU.  A better solution might be to do this work in onNewIntent
 939         // but then we would need to save it in onSaveInstanceState and restore
 940         // it in onCreate/onRestoreInstanceState
 941         if (mActiveTabsPage != null) {
 942             removeActiveTabPage(true);
 943         }
 944
 945         cancelStopToast();
 946
 947         // unregister network state listener
 948         unregisterReceiver(mNetworkStateIntentReceiver);
 949         WebView.disablePlatformNotifications();
 950     }
 951
 952     @Override
 953     protected void onDestroy() {
 954         if (LOGV_ENABLED) {
 955             Log.v(LOGTAG, "BrowserActivity.onDestroy: this=" + this);
 956         }
 957         super.onDestroy();
 958
 959         if (mUploadMessage != null) {
 960             mUploadMessage.onReceiveValue(null);
 961             mUploadMessage = null;
 962         }
 963
 964         if (mTabControl == null) return;
 965
 966         // Remove the fake title bar if it is there
 967         hideFakeTitleBar();
 968
 969         // Remove the current tab and sub window
 970         Tab t = mTabControl.getCurrentTab();
 971         if (t != null) {
 972             dismissSubWindow(t);
 973             removeTabFromContentView(t);
 974         }
 975         // Destroy all the tabs
 976         mTabControl.destroy();
 977         WebIconDatabase.getInstance().close();
 978
 979         unregisterReceiver(mPackageInstallationReceiver);
 980
 981         // Stop watching the default geolocation permissions
 982         mSystemAllowGeolocationOrigins.stop();
 983         mSystemAllowGeolocationOrigins = null;
 984     }
 985
 986     @Override
 987     public void onConfigurationChanged(Configuration newConfig) {
 988         mConfigChanged = true;
 989         super.onConfigurationChanged(newConfig);
 990
 991         if (mPageInfoDialog != null) {
 992             mPageInfoDialog.dismiss();
 993             showPageInfo(
 994                 mPageInfoView,
 995                 mPageInfoFromShowSSLCertificateOnError);
 996         }
 997         if (mSSLCertificateDialog != null) {
 998             mSSLCertificateDialog.dismiss();
 999             showSSLCertificate(
1000                 mSSLCertificateView);
1001         }
1002         if (mSSLCertificateOnErrorDialog != null) {
1003             mSSLCertificateOnErrorDialog.dismiss();
1004             showSSLCertificateOnError(
1005                 mSSLCertificateOnErrorView,
1006                 mSSLCertificateOnErrorHandler,
1007                 mSSLCertificateOnErrorError);
1008         }
1009         if (mHttpAuthenticationDialog != null) {
1010             String title = ((TextView) mHttpAuthenticationDialog
1011                     .findViewById(com.android.internal.R.id.alertTitle)).getText()
1012                     .toString();
1013             String name = ((TextView) mHttpAuthenticationDialog
1014                     .findViewById(R.id.username_edit)).getText().toString();
1015             String password = ((TextView) mHttpAuthenticationDialog
1016                     .findViewById(R.id.password_edit)).getText().toString();
1017             int focusId = mHttpAuthenticationDialog.getCurrentFocus()
1018                     .getId();
1019             mHttpAuthenticationDialog.dismiss();
1020             showHttpAuthentication(mHttpAuthHandler, null, null, title,
1021                     name, password, focusId);
1022         }
1023     }
1024
1025     @Override
1026     public void onLowMemory() {
1027         super.onLowMemory();
1028         mTabControl.freeMemory();
1029     }
1030
1031     private void resumeWebViewTimers() {
1032         Tab tab = mTabControl.getCurrentTab();
1033         if (tab == null) return; // monkey can trigger this
1034         boolean inLoad = tab.inLoad();
1035         if ((!mActivityInPause && !inLoad) || (mActivityInPause && inLoad)) {
1036             CookieSyncManager.getInstance().startSync();
1037             WebView w = tab.getWebView();
1038             if (w != null) {
1039                 w.resumeTimers();
1040             }
1041         }
1042     }
1043
1044     private boolean pauseWebViewTimers() {
1045         Tab tab = mTabControl.getCurrentTab();
1046         boolean inLoad = tab.inLoad();
1047         if (mActivityInPause && !inLoad) {
1048             CookieSyncManager.getInstance().stopSync();
1049             WebView w = mTabControl.getCurrentWebView();
1050             if (w != null) {
1051                 w.pauseTimers();
1052             }
1053             return true;
1054         } else {
1055             return false;
1056         }
1057     }
1058
1059     // Open the icon database and retain all the icons for visited sites.
1060     private void retainIconsOnStartup() {
1061         final WebIconDatabase db = WebIconDatabase.getInstance();
1062         db.open(getDir("icons", 0).getPath());
1063         Cursor c = null;
1064         try {
1065             c = Browser.getAllBookmarks(mResolver);
1066             if (c.moveToFirst()) {
1067                 int urlIndex = c.getColumnIndex(Browser.BookmarkColumns.URL);
1068                 do {
1069                     String url = c.getString(urlIndex);
1070                     db.retainIconForPageUrl(url);
1071                 } while (c.moveToNext());
1072             }
1073         } catch (IllegalStateException e) {
1074             Log.e(LOGTAG, "retainIconsOnStartup", e);
1075         } finally {
1076             if (c!= null) c.close();
1077         }
1078     }
1079
1080     // Helper method for getting the top window.
1081     WebView getTopWindow() {
1082         return mTabControl.getCurrentTopWebView();
1083     }
1084
1085     TabControl getTabControl() {
1086         return mTabControl;
1087     }
1088
1089     @Override
1090     public boolean onCreateOptionsMenu(Menu menu) {
1091         super.onCreateOptionsMenu(menu);
1092
1093         MenuInflater inflater = getMenuInflater();
1094         inflater.inflate(R.menu.browser, menu);
1095         mMenu = menu;
1096         updateInLoadMenuItems();
1097         return true;
1098     }
1099
1100     /**
1101      * As the menu can be open when loading state changes
1102      * we must manually update the state of the stop/reload menu
1103      * item
1104      */
1105     private void updateInLoadMenuItems() {
1106         if (mMenu == null) {
1107             return;
1108         }
1109         MenuItem src = mInLoad ?
1110                 mMenu.findItem(R.id.stop_menu_id):
1111                     mMenu.findItem(R.id.reload_menu_id);
1112         MenuItem dest = mMenu.findItem(R.id.stop_reload_menu_id);
1113         dest.setIcon(src.getIcon());
1114         dest.setTitle(src.getTitle());
1115     }
1116
1117     @Override
1118     public boolean onContextItemSelected(MenuItem item) {
1119         // chording is not an issue with context menus, but we use the same
1120         // options selector, so set mCanChord to true so we can access them.
1121         mCanChord = true;
1122         int id = item.getItemId();
1123         boolean result = true;
1124         switch (id) {
1125             // For the context menu from the title bar
1126             case R.id.title_bar_copy_page_url:
1127                 Tab currentTab = mTabControl.getCurrentTab();
1128                 if (null == currentTab) {
1129                     result = false;
1130                     break;
1131                 }
1132                 WebView mainView = currentTab.getWebView();
1133                 if (null == mainView) {
1134                     result = false;
1135                     break;
1136                 }
1137                 copy(mainView.getUrl());
1138                 break;
1139             // -- Browser context menu
1140             case R.id.open_context_menu_id:
1141             case R.id.open_newtab_context_menu_id:
1142             case R.id.bookmark_context_menu_id:
1143             case R.id.save_link_context_menu_id:
1144             case R.id.share_link_context_menu_id:
1145             case R.id.copy_link_context_menu_id:
1146                 final WebView webView = getTopWindow();
1147                 if (null == webView) {
1148                     result = false;
1149                     break;
1150                 }
1151                 final HashMap hrefMap = new HashMap();
1152                 hrefMap.put("webview", webView);
1153                 final Message msg = mHandler.obtainMessage(
1154                         FOCUS_NODE_HREF, id, 0, hrefMap);
1155                 webView.requestFocusNodeHref(msg);
1156                 break;
1157
1158             default:
1159                 // For other context menus
1160                 result = onOptionsItemSelected(item);
1161         }
1162         mCanChord = false;
1163         return result;
1164     }
1165
1166     private Bundle createGoogleSearchSourceBundle(String source) {
1167         Bundle bundle = new Bundle();
1168         bundle.putString(Search.SOURCE, source);
1169         return bundle;
1170     }
1171
1172     /* package */ void editUrl() {
1173         if (mOptionsMenuOpen) closeOptionsMenu();
1174         String url = (getTopWindow() == null) ? null : getTopWindow().getUrl();
1175         startSearch(mSettings.getHomePage().equals(url) ? null : url, true,
1176                 null, false);
1177     }
1178
1179     /**
1180      * Overriding this to insert a local information bundle
1181      */
1182     @Override
1183     public void startSearch(String initialQuery, boolean selectInitialQuery,
1184             Bundle appSearchData, boolean globalSearch) {
1185         if (appSearchData == null) {
1186             appSearchData = createGoogleSearchSourceBundle(GOOGLE_SEARCH_SOURCE_TYPE);
1187         }
1188         super.startSearch(initialQuery, selectInitialQuery, appSearchData, globalSearch);
1189     }
1190
1191     /**
1192      * Switch tabs.  Called by the TitleBarSet when sliding the title bar
1193      * results in changing tabs.
1194      * @param index Index of the tab to change to, as defined by
1195      *              mTabControl.getTabIndex(Tab t).
1196      * @return boolean True if we successfully switched to a different tab.  If
1197      *                 the indexth tab is null, or if that tab is the same as
1198      *                 the current one, return false.
1199      */
1200     /* package */ boolean switchToTab(int index) {
1201         Tab tab = mTabControl.getTab(index);
1202         Tab currentTab = mTabControl.getCurrentTab();
1203         if (tab == null || tab == currentTab) {
1204             return false;
1205         }
1206         if (currentTab != null) {
1207             // currentTab may be null if it was just removed.  In that case,
1208             // we do not need to remove it
1209             removeTabFromContentView(currentTab);
1210         }
1211         mTabControl.setCurrentTab(tab);
1212         attachTabToContentView(tab);
1213         resetTitleIconAndProgress();
1214         updateLockIconToLatest();
1215         return true;
1216     }
1217
1218     /* package */ Tab openTabToHomePage() {
1219         return openTabAndShow(mSettings.getHomePage(), false, null);
1220     }
1221
1222     /* package */ void closeCurrentWindow() {
1223         final Tab current = mTabControl.getCurrentTab();
1224         if (mTabControl.getTabCount() == 1) {
1225             // This is the last tab.  Open a new one, with the home
1226             // page and close the current one.
1227             openTabToHomePage();
1228             closeTab(current);
1229             return;
1230         }
1231         final Tab parent = current.getParentTab();
1232         int indexToShow = -1;
1233         if (parent != null) {
1234             indexToShow = mTabControl.getTabIndex(parent);
1235         } else {
1236             final int currentIndex = mTabControl.getCurrentIndex();
1237             // Try to move to the tab to the right
1238             indexToShow = currentIndex + 1;
1239             if (indexToShow > mTabControl.getTabCount() - 1) {
1240                 // Try to move to the tab to the left
1241                 indexToShow = currentIndex - 1;
1242             }
1243         }
1244         if (switchToTab(indexToShow)) {
1245             // Close window
1246             closeTab(current);
1247         }
1248     }
1249
1250     private ActiveTabsPage mActiveTabsPage;
1251
1252     /**
1253      * Remove the active tabs page.
1254      * @param needToAttach If true, the active tabs page did not attach a tab
1255      *                     to the content view, so we need to do that here.
1256      */
1257     /* package */ void removeActiveTabPage(boolean needToAttach) {
1258         mContentView.removeView(mActiveTabsPage);
1259         mActiveTabsPage = null;
1260         mMenuState = R.id.MAIN_MENU;
1261         if (needToAttach) {
1262             attachTabToContentView(mTabControl.getCurrentTab());
1263         }
1264         getTopWindow().requestFocus();
1265     }
1266
1267     @Override
1268     public boolean onOptionsItemSelected(MenuItem item) {
1269         if (!mCanChord) {
1270             // The user has already fired a shortcut with this hold down of the
1271             // menu key.
1272             return false;
1273         }
1274         if (null == getTopWindow()) {
1275             return false;
1276         }
1277         if (mMenuIsDown) {
1278             // The shortcut action consumes the MENU. Even if it is still down,
1279             // it won't trigger the next shortcut action. In the case of the
1280             // shortcut action triggering a new activity, like Bookmarks, we
1281             // won't get onKeyUp for MENU. So it is important to reset it here.
1282             mMenuIsDown = false;
1283         }
1284         switch (item.getItemId()) {
1285             // -- Main menu
1286             case R.id.new_tab_menu_id:
1287                 openTabToHomePage();
1288                 break;
1289
1290             case R.id.goto_menu_id:
1291                 editUrl();
1292                 break;
1293
1294             case R.id.bookmarks_menu_id:
1295                 bookmarksOrHistoryPicker(false);
1296                 break;
1297
1298             case R.id.active_tabs_menu_id:
1299                 mActiveTabsPage = new ActiveTabsPage(this, mTabControl);
1300                 removeTabFromContentView(mTabControl.getCurrentTab());
1301                 hideFakeTitleBar();
1302                 mContentView.addView(mActiveTabsPage, COVER_SCREEN_PARAMS);
1303                 mActiveTabsPage.requestFocus();
1304                 mMenuState = EMPTY_MENU;
1305                 break;
1306
1307             case R.id.add_bookmark_menu_id:
1308                 Intent i = new Intent(BrowserActivity.this,
1309                         AddBookmarkPage.class);
1310                 WebView w = getTopWindow();
1311                 i.putExtra("url", w.getUrl());
1312                 i.putExtra("title", w.getTitle());
1313                 i.putExtra("touch_icon_url", w.getTouchIconUrl());
1314                 i.putExtra("thumbnail", createScreenshot(w));
1315                 startActivity(i);
1316                 break;
1317
1318             case R.id.stop_reload_menu_id:
1319                 if (mInLoad) {
1320                     stopLoading();
1321                 } else {
1322                     getTopWindow().reload();
1323                 }
1324                 break;
1325
1326             case R.id.back_menu_id:
1327                 getTopWindow().goBack();
1328                 break;
1329
1330             case R.id.forward_menu_id:
1331                 getTopWindow().goForward();
1332                 break;
1333
1334             case R.id.close_menu_id:
1335                 // Close the subwindow if it exists.
1336                 if (mTabControl.getCurrentSubWindow() != null) {
1337                     dismissSubWindow(mTabControl.getCurrentTab());
1338                     break;
1339                 }
1340                 closeCurrentWindow();
1341                 break;
1342
1343             case R.id.homepage_menu_id:
1344                 Tab current = mTabControl.getCurrentTab();
1345                 if (current != null) {
1346                     dismissSubWindow(current);
1347                     loadUrl(current.getWebView(), mSettings.getHomePage());
1348                 }
1349                 break;
1350
1351             case R.id.preferences_menu_id:
1352                 Intent intent = new Intent(this,
1353                         BrowserPreferencesPage.class);
1354                 intent.putExtra(BrowserPreferencesPage.CURRENT_PAGE,
1355                         getTopWindow().getUrl());
1356                 startActivityForResult(intent, PREFERENCES_PAGE);
1357                 break;
1358
1359             case R.id.find_menu_id:
1360                 if (null == mFindDialog) {
1361                     mFindDialog = new FindDialog(this);
1362                 }
1363                 mFindDialog.setWebView(getTopWindow());
1364                 mFindDialog.show();
1365                 getTopWindow().setFindIsUp(true);
1366                 mMenuState = EMPTY_MENU;
1367                 break;
1368
1369             case R.id.select_text_id:
1370                 getTopWindow().emulateShiftHeld();
1371                 break;
1372             case R.id.page_info_menu_id:
1373                 showPageInfo(mTabControl.getCurrentTab(), false);
1374                 break;
1375
1376             case R.id.classic_history_menu_id:
1377                 bookmarksOrHistoryPicker(true);
1378                 break;
1379
1380             case R.id.title_bar_share_page_url:
1381             case R.id.share_page_menu_id:
1382                 Tab currentTab = mTabControl.getCurrentTab();
1383                 if (null == currentTab) {
1384                     mCanChord = false;
1385                     return false;
1386                 }
1387                 currentTab.populatePickerData();
1388                 sharePage(this, currentTab.getTitle(),
1389                         currentTab.getUrl(), currentTab.getFavicon(),
1390                         createScreenshot(currentTab.getWebView()));
1391                 break;
1392
1393             case R.id.dump_nav_menu_id:
1394                 getTopWindow().debugDump();
1395                 break;
1396
1397             case R.id.dump_counters_menu_id:
1398                 getTopWindow().dumpV8Counters();
1399                 break;
1400
1401             case R.id.zoom_in_menu_id:
1402                 getTopWindow().zoomIn();
1403                 break;
1404
1405             case R.id.zoom_out_menu_id:
1406                 getTopWindow().zoomOut();
1407                 break;
1408
1409             case R.id.view_downloads_menu_id:
1410                 viewDownloads(null);
1411                 break;
1412
1413             case R.id.window_one_menu_id:
1414             case R.id.window_two_menu_id:
1415             case R.id.window_three_menu_id:
1416             case R.id.window_four_menu_id:
1417             case R.id.window_five_menu_id:
1418             case R.id.window_six_menu_id:
1419             case R.id.window_seven_menu_id:
1420             case R.id.window_eight_menu_id:
1421                 {
1422                     int menuid = item.getItemId();
1423                     for (int id = 0; id < WINDOW_SHORTCUT_ID_ARRAY.length; id++) {
1424                         if (WINDOW_SHORTCUT_ID_ARRAY[id] == menuid) {
1425                             Tab desiredTab = mTabControl.getTab(id);
1426                             if (desiredTab != null &&
1427                                     desiredTab != mTabControl.getCurrentTab()) {
1428                                 switchToTab(id);
1429                             }
1430                             break;
1431                         }
1432                     }
1433                 }
1434                 break;
1435
1436             default:
1437                 if (!super.onOptionsItemSelected(item)) {
1438                     return false;
1439                 }
1440                 // Otherwise fall through.
1441         }
1442         mCanChord = false;
1443         return true;
1444     }
1445
1446     public void closeFind() {
1447         mMenuState = R.id.MAIN_MENU;
1448     }
1449
1450     @Override
1451     public boolean onPrepareOptionsMenu(Menu menu) {
1452         // This happens when the user begins to hold down the menu key, so
1453         // allow them to chord to get a shortcut.
1454         mCanChord = true;
1455         // Note: setVisible will decide whether an item is visible; while
1456         // setEnabled() will decide whether an item is enabled, which also means
1457         // whether the matching shortcut key will function.
1458         super.onPrepareOptionsMenu(menu);
1459         switch (mMenuState) {
1460             case EMPTY_MENU:
1461                 if (mCurrentMenuState != mMenuState) {
1462                     menu.setGroupVisible(R.id.MAIN_MENU, false);
1463                     menu.setGroupEnabled(R.id.MAIN_MENU, false);
1464                     menu.setGroupEnabled(R.id.MAIN_SHORTCUT_MENU, false);
1465                 }
1466                 break;
1467             default:
1468                 if (mCurrentMenuState != mMenuState) {
1469                     menu.setGroupVisible(R.id.MAIN_MENU, true);
1470                     menu.setGroupEnabled(R.id.MAIN_MENU, true);
1471                     menu.setGroupEnabled(R.id.MAIN_SHORTCUT_MENU, true);
1472                 }
1473                 final WebView w = getTopWindow();
1474                 boolean canGoBack = false;
1475                 boolean canGoForward = false;
1476                 boolean isHome = false;
1477                 if (w != null) {
1478                     canGoBack = w.canGoBack();
1479                     canGoForward = w.canGoForward();
1480                     isHome = mSettings.getHomePage().equals(w.getUrl());
1481                 }
1482                 final MenuItem back = menu.findItem(R.id.back_menu_id);
1483                 back.setEnabled(canGoBack);
1484
1485                 final MenuItem home = menu.findItem(R.id.homepage_menu_id);
1486                 home.setEnabled(!isHome);
1487
1488                 menu.findItem(R.id.forward_menu_id)
1489                         .setEnabled(canGoForward);
1490
1491                 menu.findItem(R.id.new_tab_menu_id).setEnabled(
1492                         mTabControl.canCreateNewTab());
1493
1494                 // decide whether to show the share link option
1495                 PackageManager pm = getPackageManager();
1496                 Intent send = new Intent(Intent.ACTION_SEND);
1497                 send.setType("text/plain");
1498                 ResolveInfo ri = pm.resolveActivity(send, PackageManager.MATCH_DEFAULT_ONLY);
1499                 menu.findItem(R.id.share_page_menu_id).setVisible(ri != null);
1500
1501                 boolean isNavDump = mSettings.isNavDump();
1502                 final MenuItem nav = menu.findItem(R.id.dump_nav_menu_id);
1503                 nav.setVisible(isNavDump);
1504                 nav.setEnabled(isNavDump);
1505
1506                 boolean showDebugSettings = mSettings.showDebugSettings();
1507                 final MenuItem counter = menu.findItem(R.id.dump_counters_menu_id);
1508                 counter.setVisible(showDebugSettings);
1509                 counter.setEnabled(showDebugSettings);
1510
1511                 break;
1512         }
1513         mCurrentMenuState = mMenuState;
1514         return true;
1515     }
1516
1517     @Override
1518     public void onCreateContextMenu(ContextMenu menu, View v,
1519             ContextMenuInfo menuInfo) {
1520         if (v instanceof TitleBar) {
1521             return;
1522         }
1523         WebView webview = (WebView) v;
1524         WebView.HitTestResult result = webview.getHitTestResult();
1525         if (result == null) {
1526             return;
1527         }
1528
1529         int type = result.getType();
1530         if (type == WebView.HitTestResult.UNKNOWN_TYPE) {
1531             Log.w(LOGTAG,
1532                     "We should not show context menu when nothing is touched");
1533             return;
1534         }
1535         if (type == WebView.HitTestResult.EDIT_TEXT_TYPE) {
1536             // let TextView handles context menu
1537             return;
1538         }
1539
1540         // Note, http://b/issue?id=1106666 is requesting that
1541         // an inflated menu can be used again. This is not available
1542         // yet, so inflate each time (yuk!)
1543         MenuInflater inflater = getMenuInflater();
1544         inflater.inflate(R.menu.browsercontext, menu);
1545
1546         // Show the correct menu group
1547         String extra = result.getExtra();
1548         menu.setGroupVisible(R.id.PHONE_MENU,
1549                 type == WebView.HitTestResult.PHONE_TYPE);
1550         menu.setGroupVisible(R.id.EMAIL_MENU,
1551                 type == WebView.HitTestResult.EMAIL_TYPE);
1552         menu.setGroupVisible(R.id.GEO_MENU,
1553                 type == WebView.HitTestResult.GEO_TYPE);
1554         menu.setGroupVisible(R.id.IMAGE_MENU,
1555                 type == WebView.HitTestResult.IMAGE_TYPE
1556                 || type == WebView.HitTestResult.SRC_IMAGE_ANCHOR_TYPE);
1557         menu.setGroupVisible(R.id.ANCHOR_MENU,
1558                 type == WebView.HitTestResult.SRC_ANCHOR_TYPE
1559                 || type == WebView.HitTestResult.SRC_IMAGE_ANCHOR_TYPE);
1560
1561         // Setup custom handling depending on the type
1562         switch (type) {
1563             case WebView.HitTestResult.PHONE_TYPE:
1564                 menu.setHeaderTitle(Uri.decode(extra));
1565                 menu.findItem(R.id.dial_context_menu_id).setIntent(
1566                         new Intent(Intent.ACTION_VIEW, Uri
1567                                 .parse(WebView.SCHEME_TEL + extra)));
1568                 Intent addIntent = new Intent(Intent.ACTION_INSERT_OR_EDIT);
1569                 addIntent.putExtra(Insert.PHONE, Uri.decode(extra));
1570                 addIntent.setType(ContactsContract.Contacts.CONTENT_ITEM_TYPE);
1571                 menu.findItem(R.id.add_contact_context_menu_id).setIntent(
1572                         addIntent);
1573                 menu.findItem(R.id.copy_phone_context_menu_id).setOnMenuItemClickListener(
1574                         new Copy(extra));
1575                 break;
1576
1577             case WebView.HitTestResult.EMAIL_TYPE:
1578                 menu.setHeaderTitle(extra);
1579                 menu.findItem(R.id.email_context_menu_id).setIntent(
1580                         new Intent(Intent.ACTION_VIEW, Uri
1581                                 .parse(WebView.SCHEME_MAILTO + extra)));
1582                 menu.findItem(R.id.copy_mail_context_menu_id).setOnMenuItemClickListener(
1583                         new Copy(extra));
1584                 break;
1585
1586             case WebView.HitTestResult.GEO_TYPE:
1587                 menu.setHeaderTitle(extra);
1588                 menu.findItem(R.id.map_context_menu_id).setIntent(
1589                         new Intent(Intent.ACTION_VIEW, Uri
1590                                 .parse(WebView.SCHEME_GEO
1591                                         + URLEncoder.encode(extra))));
1592                 menu.findItem(R.id.copy_geo_context_menu_id).setOnMenuItemClickListener(
1593                         new Copy(extra));
1594                 break;
1595
1596             case WebView.HitTestResult.SRC_ANCHOR_TYPE:
1597             case WebView.HitTestResult.SRC_IMAGE_ANCHOR_TYPE:
1598                 TextView titleView = (TextView) LayoutInflater.from(this)
1599                         .inflate(android.R.layout.browser_link_context_header,
1600                         null);
1601                 titleView.setText(extra);
1602                 menu.setHeaderView(titleView);
1603                 // decide whether to show the open link in new tab option
1604                 menu.findItem(R.id.open_newtab_context_menu_id).setVisible(
1605                         mTabControl.canCreateNewTab());
1606                 menu.findItem(R.id.bookmark_context_menu_id).setVisible(
1607                         Bookmarks.urlHasAcceptableScheme(extra));
1608                 PackageManager pm = getPackageManager();
1609                 Intent send = new Intent(Intent.ACTION_SEND);
1610                 send.setType("text/plain");
1611                 ResolveInfo ri = pm.resolveActivity(send, PackageManager.MATCH_DEFAULT_ONLY);
1612                 menu.findItem(R.id.share_link_context_menu_id).setVisible(ri != null);
1613                 if (type == WebView.HitTestResult.SRC_ANCHOR_TYPE) {
1614                     break;
1615                 }
1616                 // otherwise fall through to handle image part
1617             case WebView.HitTestResult.IMAGE_TYPE:
1618                 if (type == WebView.HitTestResult.IMAGE_TYPE) {
1619                     menu.setHeaderTitle(extra);
1620                 }
1621                 menu.findItem(R.id.view_image_context_menu_id).setIntent(
1622                         new Intent(Intent.ACTION_VIEW, Uri.parse(extra)));
1623                 menu.findItem(R.id.download_context_menu_id).
1624                         setOnMenuItemClickListener(new Download(extra));
1625                 menu.findItem(R.id.set_wallpaper_context_menu_id).
1626                         setOnMenuItemClickListener(new SetAsWallpaper(extra));
1627                 break;
1628
1629             default:
1630                 Log.w(LOGTAG, "We should not get here.");
1631                 break;
1632         }
1633         hideFakeTitleBar();
1634     }
1635
1636     // Attach the given tab to the content view.
1637     // this should only be called for the current tab.
1638     private void attachTabToContentView(Tab t) {
1639         // Attach the container that contains the main WebView and any other UI
1640         // associated with the tab.
1641         t.attachTabToContentView(mContentView);
1642
1643         if (mShouldShowErrorConsole) {
1644             ErrorConsoleView errorConsole = t.getErrorConsole(true);
1645             if (errorConsole.numberOfErrors() == 0) {
1646                 errorConsole.showConsole(ErrorConsoleView.SHOW_NONE);
1647             } else {
1648                 errorConsole.showConsole(ErrorConsoleView.SHOW_MINIMIZED);
1649             }
1650
1651             mErrorConsoleContainer.addView(errorConsole,
1652                     new LinearLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,
1653                                                   ViewGroup.LayoutParams.WRAP_CONTENT));
1654         }
1655
1656         WebView view = t.getWebView();
1657         view.setEmbeddedTitleBar(mTitleBar);
1658         if (t.isInVoiceSearchMode()) {
1659             showVoiceTitleBar(t.getVoiceDisplayTitle());
1660         } else {
1661             revertVoiceTitleBar();
1662         }
1663         // Request focus on the top window.
1664         t.getTopWindow().requestFocus();
1665     }
1666
1667     // Attach a sub window to the main WebView of the given tab.
1668     void attachSubWindow(Tab t) {
1669         t.attachSubWindow(mContentView);
1670         getTopWindow().requestFocus();
1671     }
1672
1673     // Remove the given tab from the content view.
1674     private void removeTabFromContentView(Tab t) {
1675         // Remove the container that contains the main WebView.
1676         t.removeTabFromContentView(mContentView);
1677
1678         ErrorConsoleView errorConsole = t.getErrorConsole(false);
1679         if (errorConsole != null) {
1680             mErrorConsoleContainer.removeView(errorConsole);
1681         }
1682
1683         WebView view = t.getWebView();
1684         if (view != null) {
1685             view.setEmbeddedTitleBar(null);
1686         }
1687     }
1688
1689     // Remove the sub window if it exists. Also called by TabControl when the
1690     // user clicks the 'X' to dismiss a sub window.
1691     /* package */ void dismissSubWindow(Tab t) {
1692         t.removeSubWindow(mContentView);
1693         // dismiss the subwindow. This will destroy the WebView.
1694         t.dismissSubWindow();
1695         getTopWindow().requestFocus();
1696     }
1697
1698     // A wrapper function of {@link #openTabAndShow(UrlData, boolean, String)}
1699     // that accepts url as string.
1700     private Tab openTabAndShow(String url, boolean closeOnExit, String appId) {
1701         return openTabAndShow(new UrlData(url), closeOnExit, appId);
1702     }
1703
1704     // This method does a ton of stuff. It will attempt to create a new tab
1705     // if we haven't reached MAX_TABS. Otherwise it uses the current tab. If
1706     // url isn't null, it will load the given url.
1707     /* package */Tab openTabAndShow(UrlData urlData, boolean closeOnExit,
1708             String appId) {
1709         final Tab currentTab = mTabControl.getCurrentTab();
1710         if (mTabControl.canCreateNewTab()) {
1711             final Tab tab = mTabControl.createNewTab(closeOnExit, appId,
1712                     urlData.mUrl);
1713             WebView webview = tab.getWebView();
1714             // If the last tab was removed from the active tabs page, currentTab
1715             // will be null.
1716             if (currentTab != null) {
1717                 removeTabFromContentView(currentTab);
1718             }
1719             // We must set the new tab as the current tab to reflect the old
1720             // animation behavior.
1721             mTabControl.setCurrentTab(tab);
1722             attachTabToContentView(tab);
1723             if (!urlData.isEmpty()) {
1724                 loadUrlDataIn(tab, urlData);
1725             }
1726             return tab;
1727         } else {
1728             // Get rid of the subwindow if it exists
1729             dismissSubWindow(currentTab);
1730             if (!urlData.isEmpty()) {
1731                 // Load the given url.
1732                 loadUrlDataIn(currentTab, urlData);
1733             }
1734             return currentTab;
1735         }
1736     }
1737
1738     private Tab openTab(String url) {
1739         if (mSettings.openInBackground()) {
1740             Tab t = mTabControl.createNewTab();
1741             if (t != null) {
1742                 WebView view = t.getWebView();
1743                 loadUrl(view, url);
1744             }
1745             return t;
1746         } else {
1747             return openTabAndShow(url, false, null);
1748         }
1749     }
1750
1751     private class Copy implements OnMenuItemClickListener {
1752         private CharSequence mText;
1753
1754         public boolean onMenuItemClick(MenuItem item) {
1755             copy(mText);
1756             return true;
1757         }
1758
1759         public Copy(CharSequence toCopy) {
1760             mText = toCopy;
1761         }
1762     }
1763
1764     private class Download implements OnMenuItemClickListener {
1765         private String mText;
1766
1767         public boolean onMenuItemClick(MenuItem item) {
1768             onDownloadStartNoStream(mText, null, null, null, -1);
1769             return true;
1770         }
1771
1772         public Download(String toDownload) {
1773             mText = toDownload;
1774         }
1775     }
1776
1777     private class SetAsWallpaper extends Thread implements
1778             OnMenuItemClickListener, DialogInterface.OnCancelListener {
1779         private URL mUrl;
1780         private ProgressDialog mWallpaperProgress;
1781         private boolean mCanceled = false;
1782
1783         public SetAsWallpaper(String url) {
1784             try {
1785                 mUrl = new URL(url);
1786             } catch (MalformedURLException e) {
1787                 mUrl = null;
1788             }
1789         }
1790
1791         public void onCancel(DialogInterface dialog) {
1792             mCanceled = true;
1793         }
1794
1795         public boolean onMenuItemClick(MenuItem item) {
1796             if (mUrl != null) {
1797                 // The user may have tried to set a image with a large file size as their
1798                 // background so it may take a few moments to perform the operation. Display
1799                 // a progress spinner while it is working.
1800                 mWallpaperProgress = new ProgressDialog(BrowserActivity.this);
1801                 mWallpaperProgress.setIndeterminate(true);
1802                 mWallpaperProgress.setMessage(getText(R.string.progress_dialog_setting_wallpaper));
1803                 mWallpaperProgress.setCancelable(true);
1804                 mWallpaperProgress.setOnCancelListener(this);
1805                 mWallpaperProgress.show();
1806                 start();
1807             }
1808             return true;
1809         }
1810
1811         public void run() {
1812             Drawable oldWallpaper = BrowserActivity.this.getWallpaper();
1813             try {
1814                 // TODO: This will cause the resource to be downloaded again, when we
1815                 // should in most cases be able to grab it from the cache. To fix this
1816                 // we should query WebCore to see if we can access a cached version and
1817                 // instead open an input stream on that. This pattern could also be used
1818                 // in the download manager where the same problem exists.
1819                 InputStream inputstream = mUrl.openStream();
1820                 if (inputstream != null) {
1821                     setWallpaper(inputstream);
1822                 }
1823             } catch (IOException e) {
1824                 Log.e(LOGTAG, "Unable to set new wallpaper");
1825                 // Act as though the user canceled the operation so we try to
1826                 // restore the old wallpaper.
1827                 mCanceled = true;
1828             }
1829
1830             if (mCanceled) {
1831                 // Restore the old wallpaper if the user cancelled whilst we were setting
1832                 // the new wallpaper.
1833                 int width = oldWallpaper.getIntrinsicWidth();
1834                 int height = oldWallpaper.getIntrinsicHeight();
1835                 Bitmap bm = Bitmap.createBitmap(width, height, Bitmap.Config.RGB_565);
1836                 Canvas canvas = new Canvas(bm);
1837                 oldWallpaper.setBounds(0, 0, width, height);
1838                 oldWallpaper.draw(canvas);
1839                 try {
1840                     setWallpaper(bm);
1841                 } catch (IOException e) {
1842                     Log.e(LOGTAG, "Unable to restore old wallpaper.");
1843                 }
1844                 mCanceled = false;
1845             }
1846
1847             if (mWallpaperProgress.isShowing()) {
1848                 mWallpaperProgress.dismiss();
1849             }
1850         }
1851     }
1852
1853     private void copy(CharSequence text) {
1854         try {
1855             IClipboard clip = IClipboard.Stub.asInterface(ServiceManager.getService("clipboard"));
1856             if (clip != null) {
1857                 clip.setClipboardText(text);
1858             }
1859         } catch (android.os.RemoteException e) {
1860             Log.e(LOGTAG, "Copy failed", e);
1861         }
1862     }
1863
1864     /**
1865      * Resets the browser title-view to whatever it must be
1866      * (for example, if we had a loading error)
1867      * When we have a new page, we call resetTitle, when we
1868      * have to reset the titlebar to whatever it used to be
1869      * (for example, if the user chose to stop loading), we
1870      * call resetTitleAndRevertLockIcon.
1871      */
1872     /* package */ void resetTitleAndRevertLockIcon() {
1873         mTabControl.getCurrentTab().revertLockIcon();
1874         updateLockIconToLatest();
1875         resetTitleIconAndProgress();
1876     }
1877
1878     /**
1879      * Reset the title, favicon, and progress.
1880      */
1881     private void resetTitleIconAndProgress() {
1882         WebView current = mTabControl.getCurrentWebView();
1883         if (current == null) {
1884             return;
1885         }
1886         resetTitleAndIcon(current);
1887         int progress = current.getProgress();
1888         current.getWebChromeClient().onProgressChanged(current, progress);
1889     }
1890
1891     // Reset the title and the icon based on the given item.
1892     private void resetTitleAndIcon(WebView view) {
1893         WebHistoryItem item = view.copyBackForwardList().getCurrentItem();
1894         if (item != null) {
1895             setUrlTitle(item.getUrl(), item.getTitle());
1896             setFavicon(item.getFavicon());
1897         } else {
1898             setUrlTitle(null, null);
1899             setFavicon(null);
1900         }
1901     }
1902
1903     /**
1904      * Sets a title composed of the URL and the title string.
1905      * @param url The URL of the site being loaded.
1906      * @param title The title of the site being loaded.
1907      */
1908     void setUrlTitle(String url, String title) {
1909         mUrl = url;
1910         mTitle = title;
1911
1912         // If we are in voice search mode, the title has already been set.
1913         if (mTabControl.getCurrentTab().isInVoiceSearchMode()) return;
1914         mTitleBar.setDisplayTitle(url);
1915         mFakeTitleBar.setDisplayTitle(url);
1916     }
1917
1918     /**
1919      * @param url The URL to build a title version of the URL from.
1920      * @return The title version of the URL or null if fails.
1921      * The title version of the URL can be either the URL hostname,
1922      * or the hostname with an "https://" prefix (for secure URLs),
1923      * or an empty string if, for example, the URL in question is a
1924      * file:// URL with no hostname.
1925      */
1926     /* package */ static String buildTitleUrl(String url) {
1927         String titleUrl = null;
1928
1929         if (url != null) {
1930             try {
1931                 // parse the url string
1932                 URL urlObj = new URL(url);
1933                 if (urlObj != null) {
1934                     titleUrl = "";
1935
1936                     String protocol = urlObj.getProtocol();
1937                     String host = urlObj.getHost();
1938
1939                     if (host != null && 0 < host.length()) {
1940                         titleUrl = host;
1941                         if (protocol != null) {
1942                             // if a secure site, add an "https://" prefix!
1943                             if (protocol.equalsIgnoreCase("https")) {
1944                                 titleUrl = protocol + "://" + host;
1945                             }
1946                         }
1947                     }
1948                 }
1949             } catch (MalformedURLException e) {}
1950         }
1951
1952         return titleUrl;
1953     }
1954
1955     // Set the favicon in the title bar.
1956     void setFavicon(Bitmap icon) {
1957         mTitleBar.setFavicon(icon);
1958         mFakeTitleBar.setFavicon(icon);
1959     }
1960
1961     /**
1962      * Close the tab, remove its associated title bar, and adjust mTabControl's
1963      * current tab to a valid value.
1964      */
1965     /* package */ void closeTab(Tab t) {
1966         int currentIndex = mTabControl.getCurrentIndex();
1967         int removeIndex = mTabControl.getTabIndex(t);
1968         mTabControl.removeTab(t);
1969         if (currentIndex >= removeIndex && currentIndex != 0) {
1970             currentIndex--;
1971         }
1972         mTabControl.setCurrentTab(mTabControl.getTab(currentIndex));
1973         resetTitleIconAndProgress();
1974     }
1975
1976     /* package */ void goBackOnePageOrQuit() {
1977         Tab current = mTabControl.getCurrentTab();
1978         if (current == null) {
1979             /*
1980              * Instead of finishing the activity, simply push this to the back
1981              * of the stack and let ActivityManager to choose the foreground
1982              * activity. As BrowserActivity is singleTask, it will be always the
1983              * root of the task. So we can use either true or false for
1984              * moveTaskToBack().
1985              */
1986             moveTaskToBack(true);
1987             return;
1988         }
1989         WebView w = current.getWebView();
1990         if (w.canGoBack()) {
1991             w.goBack();
1992         } else {
1993             // Check to see if we are closing a window that was created by
1994             // another window. If so, we switch back to that window.
1995             Tab parent = current.getParentTab();
1996             if (parent != null) {
1997                 switchToTab(mTabControl.getTabIndex(parent));
1998                 // Now we close the other tab
1999                 closeTab(current);
2000             } else {
2001                 if (current.closeOnExit()) {
2002                     // force the tab's inLoad() to be false as we are going to
2003                     // either finish the activity or remove the tab. This will
2004                     // ensure pauseWebViewTimers() taking action.
2005                     mTabControl.getCurrentTab().clearInLoad();
2006                     if (mTabControl.getTabCount() == 1) {
2007                         finish();
2008                         return;
2009                     }
2010                     // call pauseWebViewTimers() now, we won't be able to call
2011                     // it in onPause() as the WebView won't be valid.
2012                     // Temporarily change mActivityInPause to be true as
2013                     // pauseWebViewTimers() will do nothing if mActivityInPause
2014                     // is false.
2015                     boolean savedState = mActivityInPause;
2016                     if (savedState) {
2017                         Log.e(LOGTAG, "BrowserActivity is already paused "
2018                                 + "while handing goBackOnePageOrQuit.");
2019                     }
2020                     mActivityInPause = true;
2021                     pauseWebViewTimers();
2022                     mActivityInPause = savedState;
2023                     removeTabFromContentView(current);
2024                     mTabControl.removeTab(current);
2025                 }
2026                 /*
2027                  * Instead of finishing the activity, simply push this to the back
2028                  * of the stack and let ActivityManager to choose the foreground
2029                  * activity. As BrowserActivity is singleTask, it will be always the
2030                  * root of the task. So we can use either true or false for
2031                  * moveTaskToBack().
2032                  */
2033                 moveTaskToBack(true);
2034             }
2035         }
2036     }
2037
2038     boolean isMenuDown() {
2039         return mMenuIsDown;
2040     }
2041
2042     @Override
2043     public boolean onKeyDown(int keyCode, KeyEvent event) {
2044         // Even if MENU is already held down, we need to call to super to open
2045         // the IME on long press.
2046         if (KeyEvent.KEYCODE_MENU == keyCode) {
2047             mMenuIsDown = true;
2048             return super.onKeyDown(keyCode, event);
2049         }
2050         // The default key mode is DEFAULT_KEYS_SEARCH_LOCAL. As the MENU is
2051         // still down, we don't want to trigger the search. Pretend to consume
2052         // the key and do nothing.
2053         if (mMenuIsDown) return true;
2054
2055         switch(keyCode) {
2056             case KeyEvent.KEYCODE_SPACE:
2057                 // WebView/WebTextView handle the keys in the KeyDown. As
2058                 // the Activity's shortcut keys are only handled when WebView
2059                 // doesn't, have to do it in onKeyDown instead of onKeyUp.
2060                 if (event.isShiftPressed()) {
2061                     getTopWindow().pageUp(false);
2062                 } else {
2063                     getTopWindow().pageDown(false);
2064                 }
2065                 return true;
2066             case KeyEvent.KEYCODE_BACK:
2067                 if (event.getRepeatCount() == 0) {
2068                     event.startTracking();
2069                     return true;
2070                 } else if (mCustomView == null && mActiveTabsPage == null
2071                         && event.isLongPress()) {
2072                     bookmarksOrHistoryPicker(true);
2073                     return true;
2074                 }
2075                 break;
2076         }
2077         return super.onKeyDown(keyCode, event);
2078     }
2079
2080     @Override
2081     public boolean onKeyUp(int keyCode, KeyEvent event) {
2082         switch(keyCode) {
2083             case KeyEvent.KEYCODE_MENU:
2084                 mMenuIsDown = false;
2085                 break;
2086             case KeyEvent.KEYCODE_BACK:
2087                 if (event.isTracking() && !event.isCanceled()) {
2088                     if (mCustomView != null) {
2089                         // if a custom view is showing, hide it
2090                         mTabControl.getCurrentWebView().getWebChromeClient()
2091                                 .onHideCustomView();
2092                     } else if (mActiveTabsPage != null) {
2093                         // if tab page is showing, hide it
2094                         removeActiveTabPage(true);
2095                     } else {
2096                         WebView subwindow = mTabControl.getCurrentSubWindow();
2097                         if (subwindow != null) {
2098                             if (subwindow.canGoBack()) {
2099                                 subwindow.goBack();
2100                             } else {
2101                                 dismissSubWindow(mTabControl.getCurrentTab());
2102                             }
2103                         } else {
2104                             goBackOnePageOrQuit();
2105                         }
2106                     }
2107                     return true;
2108                 }
2109                 break;
2110         }
2111         return super.onKeyUp(keyCode, event);
2112     }
2113
2114     /* package */ void stopLoading() {
2115         mDidStopLoad = true;
2116         resetTitleAndRevertLockIcon();
2117         WebView w = getTopWindow();
2118         w.stopLoading();
2119         // FIXME: before refactor, it is using mWebViewClient. So I keep the
2120         // same logic here. But for subwindow case, should we call into the main
2121         // WebView's onPageFinished as we never call its onPageStarted and if
2122         // the page finishes itself, we don't call onPageFinished.
2123         mTabControl.getCurrentWebView().getWebViewClient().onPageFinished(w,
2124                 w.getUrl());
2125
2126         cancelStopToast();
2127         mStopToast = Toast
2128                 .makeText(this, R.string.stopping, Toast.LENGTH_SHORT);
2129         mStopToast.show();
2130     }
2131
2132     boolean didUserStopLoading() {
2133         return mDidStopLoad;
2134     }
2135
2136     private void cancelStopToast() {
2137         if (mStopToast != null) {
2138             mStopToast.cancel();
2139             mStopToast = null;
2140         }
2141     }
2142
2143     // called by a UI or non-UI thread to post the message
2144     public void postMessage(int what, int arg1, int arg2, Object obj,
2145             long delayMillis) {
2146         mHandler.sendMessageDelayed(mHandler.obtainMessage(what, arg1, arg2,
2147                 obj), delayMillis);
2148     }
2149
2150     // called by a UI or non-UI thread to remove the message
2151     void removeMessages(int what, Object object) {
2152         mHandler.removeMessages(what, object);
2153     }
2154
2155     // public message ids
2156     public final static int LOAD_URL                = 1001;
2157     public final static int STOP_LOAD               = 1002;
2158
2159     // Message Ids
2160     private static final int FOCUS_NODE_HREF         = 102;
2161     private static final int RELEASE_WAKELOCK        = 107;
2162
2163     static final int UPDATE_BOOKMARK_THUMBNAIL       = 108;
2164
2165     // Private handler for handling javascript and saving passwords
2166     private Handler mHandler = new Handler() {
2167
2168         public void handleMessage(Message msg) {
2169             switch (msg.what) {
2170                 case FOCUS_NODE_HREF:
2171                 {
2172                     String url = (String) msg.getData().get("url");
2173                     String title = (String) msg.getData().get("title");
2174                     if (url == null || url.length() == 0) {
2175                         break;
2176                     }
2177                     HashMap focusNodeMap = (HashMap) msg.obj;
2178                     WebView view = (WebView) focusNodeMap.get("webview");
2179                     // Only apply the action if the top window did not change.
2180                     if (getTopWindow() != view) {
2181                         break;
2182                     }
2183                     switch (msg.arg1) {
2184                         case R.id.open_context_menu_id:
2185                         case R.id.view_image_context_menu_id:
2186                             loadUrlFromContext(getTopWindow(), url);
2187                             break;
2188                         case R.id.open_newtab_context_menu_id:
2189                             final Tab parent = mTabControl.getCurrentTab();
2190                             final Tab newTab = openTab(url);
2191                             if (newTab != parent) {
2192                                 parent.addChildTab(newTab);
2193                             }
2194                             break;
2195                         case R.id.bookmark_context_menu_id:
2196                             Intent intent = new Intent(BrowserActivity.this,
2197                                     AddBookmarkPage.class);
2198                             intent.putExtra("url", url);
2199                             intent.putExtra("title", title);
2200                             startActivity(intent);
2201                             break;
2202                         case R.id.share_link_context_menu_id:
2203                             // See if this site has been visited before
2204                             StringBuilder sb = new StringBuilder(
2205                                     Browser.BookmarkColumns.URL + " = ");
2206                             DatabaseUtils.appendEscapedSQLString(sb, url);
2207                             Cursor c = mResolver.query(Browser.BOOKMARKS_URI,
2208                                     Browser.HISTORY_PROJECTION,
2209                                     sb.toString(),
2210                                     null,
2211                                     null);
2212                             if (c.moveToFirst()) {
2213                                 // The site has been visited before, so grab the
2214                                 // info from the database.
2215                                 Bitmap favicon = null;
2216                                 Bitmap thumbnail = null;
2217                                 String linkTitle = c.getString(Browser.
2218                                         HISTORY_PROJECTION_TITLE_INDEX);
2219                                 byte[] data = c.getBlob(Browser.
2220                                         HISTORY_PROJECTION_FAVICON_INDEX);
2221                                 if (data != null) {
2222                                     favicon = BitmapFactory.decodeByteArray(
2223                                             data, 0, data.length);
2224                                 }
2225                                 data = c.getBlob(Browser.
2226                                         HISTORY_PROJECTION_THUMBNAIL_INDEX);
2227                                 if (data != null) {
2228                                     thumbnail = BitmapFactory.decodeByteArray(
2229                                             data, 0, data.length);
2230                                 }
2231                                 sharePage(BrowserActivity.this,
2232                                         linkTitle, url, favicon, thumbnail);
2233                             } else {
2234                                 Browser.sendString(BrowserActivity.this, url,
2235                                         getString(
2236                                         R.string.choosertitle_sharevia));
2237                             }
2238                             break;
2239                         case R.id.copy_link_context_menu_id:
2240                             copy(url);
2241                             break;
2242                         case R.id.save_link_context_menu_id:
2243                         case R.id.download_context_menu_id:
2244                             onDownloadStartNoStream(url, null, null, null, -1);
2245                             break;
2246                     }
2247                     break;
2248                 }
2249
2250                 case LOAD_URL:
2251                     loadUrlFromContext(getTopWindow(), (String) msg.obj);
2252                     break;
2253
2254                 case STOP_LOAD:
2255                     stopLoading();
2256                     break;
2257
2258                 case RELEASE_WAKELOCK:
2259                     if (mWakeLock.isHeld()) {
2260                         mWakeLock.release();
2261                         // if we reach here, Browser should be still in the
2262                         // background loading after WAKELOCK_TIMEOUT (5-min).
2263                         // To avoid burning the battery, stop loading.
2264                         mTabControl.stopAllLoading();
2265                     }
2266                     break;
2267
2268                 case UPDATE_BOOKMARK_THUMBNAIL:
2269                     WebView view = (WebView) msg.obj;
2270                     if (view != null) {
2271                         updateScreenshot(view);
2272                     }
2273                     break;
2274             }
2275         }
2276     };
2277
2278     /**
2279      * Share a page, providing the title, url, favicon, and a screenshot.  Uses
2280      * an {@link Intent} to launch the Activity chooser.
2281      * @param c Context used to launch a new Activity.
2282      * @param title Title of the page.  Stored in the Intent with
2283      *          {@link Intent#EXTRA_SUBJECT}
2284      * @param url URL of the page.  Stored in the Intent with
2285      *          {@link Intent#EXTRA_TEXT}
2286      * @param favicon Bitmap of the favicon for the page.  Stored in the Intent
2287      *          with {@link Browser#EXTRA_SHARE_FAVICON}
2288      * @param screenshot Bitmap of a screenshot of the page.  Stored in the
2289      *          Intent with {@link Browser#EXTRA_SHARE_SCREENSHOT}
2290      */
2291     public static final void sharePage(Context c, String title, String url,
2292             Bitmap favicon, Bitmap screenshot) {
2293         Intent send = new Intent(Intent.ACTION_SEND);
2294         send.setType("text/plain");
2295         send.putExtra(Intent.EXTRA_TEXT, url);
2296         send.putExtra(Intent.EXTRA_SUBJECT, title);
2297         send.putExtra(Browser.EXTRA_SHARE_FAVICON, favicon);
2298         send.putExtra(Browser.EXTRA_SHARE_SCREENSHOT, screenshot);
2299         try {
2300             c.startActivity(Intent.createChooser(send, c.getString(
2301                     R.string.choosertitle_sharevia)));
2302         } catch(android.content.ActivityNotFoundException ex) {
2303             // if no app handles it, do nothing
2304         }
2305     }
2306
2307     private void updateScreenshot(WebView view) {
2308         // If this is a bookmarked site, add a screenshot to the database.
2309         // FIXME: When should we update?  Every time?
2310         // FIXME: Would like to make sure there is actually something to
2311         // draw, but the API for that (WebViewCore.pictureReady()) is not
2312         // currently accessible here.
2313
2314         ContentResolver cr = getContentResolver();
2315         final Cursor c = BrowserBookmarksAdapter.queryBookmarksForUrl(
2316                 cr, view.getOriginalUrl(), view.getUrl(), true);
2317         if (c != null) {
2318             boolean succeed = c.moveToFirst();
2319             ContentValues values = null;
2320             while (succeed) {
2321                 if (values == null) {
2322                     final ByteArrayOutputStream os
2323                             = new ByteArrayOutputStream();
2324                     Bitmap bm = createScreenshot(view);
2325                     if (bm == null) {
2326                         c.close();
2327                         return;
2328                     }
2329                     bm.compress(Bitmap.CompressFormat.PNG, 100, os);
2330                     values = new ContentValues();
2331                     values.put(Browser.BookmarkColumns.THUMBNAIL,
2332                             os.toByteArray());
2333                 }
2334                 cr.update(ContentUris.withAppendedId(Browser.BOOKMARKS_URI,
2335                         c.getInt(0)), values, null, null);
2336                 succeed = c.moveToNext();
2337             }
2338             c.close();
2339         }
2340     }
2341
2342     /**
2343      * Values for the size of the thumbnail created when taking a screenshot.
2344      * Lazily initialized.  Instead of using these directly, use
2345      * getDesiredThumbnailWidth() or getDesiredThumbnailHeight().
2346      */
2347     private static int THUMBNAIL_WIDTH = 0;
2348     private static int THUMBNAIL_HEIGHT = 0;
2349
2350     /**
2351      * Return the desired width for thumbnail screenshots, which are stored in
2352      * the database, and used on the bookmarks screen.
2353      * @param context Context for finding out the density of the screen.
2354      * @return int desired width for thumbnail screenshot.
2355      */
2356     /* package */ static int getDesiredThumbnailWidth(Context context) {
2357         if (THUMBNAIL_WIDTH == 0) {
2358             float density = context.getResources().getDisplayMetrics().density;
2359             THUMBNAIL_WIDTH = (int) (90 * density);
2360             THUMBNAIL_HEIGHT = (int) (80 * density);
2361         }
2362         return THUMBNAIL_WIDTH;
2363     }
2364
2365     /**
2366      * Return the desired height for thumbnail screenshots, which are stored in
2367      * the database, and used on the bookmarks screen.
2368      * @param context Context for finding out the density of the screen.
2369      * @return int desired height for thumbnail screenshot.
2370      */
2371     /* package */ static int getDesiredThumbnailHeight(Context context) {
2372         // To ensure that they are both initialized.
2373         getDesiredThumbnailWidth(context);
2374         return THUMBNAIL_HEIGHT;
2375     }
2376
2377     private Bitmap createScreenshot(WebView view) {
2378         Picture thumbnail = view.capturePicture();
2379         if (thumbnail == null) {
2380             return null;
2381         }
2382         Bitmap bm = Bitmap.createBitmap(getDesiredThumbnailWidth(this),
2383                 getDesiredThumbnailHeight(this), Bitmap.Config.ARGB_4444);
2384         Canvas canvas = new Canvas(bm);
2385         // May need to tweak these values to determine what is the
2386         // best scale factor
2387         int thumbnailWidth = thumbnail.getWidth();
2388         int thumbnailHeight = thumbnail.getHeight();
2389         float scaleFactorX = 1.0f;
2390         float scaleFactorY = 1.0f;
2391         if (thumbnailWidth > 0) {
2392             scaleFactorX = (float) getDesiredThumbnailWidth(this) /
2393                     (float)thumbnailWidth;
2394         } else {
2395             return null;
2396         }
2397
2398         if (view.getWidth() > view.getHeight() &&
2399                 thumbnailHeight < view.getHeight() && thumbnailHeight > 0) {
2400             // If the device is in landscape and the page is shorter
2401             // than the height of the view, stretch the thumbnail to fill the
2402             // space.
2403             scaleFactorY = (float) getDesiredThumbnailHeight(this) /
2404                     (float)thumbnailHeight;
2405         } else {
2406             // In the portrait case, this looks nice.
2407             scaleFactorY = scaleFactorX;
2408         }
2409
2410         canvas.scale(scaleFactorX, scaleFactorY);
2411
2412         thumbnail.draw(canvas);
2413         return bm;
2414     }
2415
2416     // -------------------------------------------------------------------------
2417     // Helper function for WebViewClient.
2418     //-------------------------------------------------------------------------
2419
2420     // Use in overrideUrlLoading
2421     /* package */ final static String SCHEME_WTAI = "wtai://wp/";
2422     /* package */ final static String SCHEME_WTAI_MC = "wtai://wp/mc;";
2423     /* package */ final static String SCHEME_WTAI_SD = "wtai://wp/sd;";
2424     /* package */ final static String SCHEME_WTAI_AP = "wtai://wp/ap;";
2425
2426     // Keep this initial progress in sync with initialProgressValue (* 100)
2427     // in ProgressTracker.cpp
2428     private final static int INITIAL_PROGRESS = 10;
2429
2430     void onPageStarted(WebView view, String url, Bitmap favicon) {
2431         // when BrowserActivity just starts, onPageStarted may be called before
2432         // onResume as it is triggered from onCreate. Call resumeWebViewTimers
2433         // to start the timer. As we won't switch tabs while an activity is in
2434         // pause state, we can ensure calling resume and pause in pair.
2435         if (mActivityInPause) resumeWebViewTimers();
2436
2437         resetLockIcon(url);
2438         setUrlTitle(url, null);
2439         setFavicon(favicon);
2440         // Show some progress so that the user knows the page is beginning to
2441         // load
2442         onProgressChanged(view, INITIAL_PROGRESS);
2443         mDidStopLoad = false;
2444         if (!mIsNetworkUp) createAndShowNetworkDialog();
2445
2446         if (mSettings.isTracing()) {
2447             String host;
2448             try {
2449                 WebAddress uri = new WebAddress(url);
2450                 host = uri.mHost;
2451             } catch (android.net.ParseException ex) {
2452                 host = "browser";
2453             }
2454             host = host.replace('.', '_');
2455             host += ".trace";
2456             mInTrace = true;
2457             Debug.startMethodTracing(host, 20 * 1024 * 1024);
2458         }
2459
2460         // Performance probe
2461         if (false) {
2462             mStart = SystemClock.uptimeMillis();
2463             mProcessStart = Process.getElapsedCpuTime();
2464             long[] sysCpu = new long[7];
2465             if (Process.readProcFile("/proc/stat", SYSTEM_CPU_FORMAT, null,
2466                     sysCpu, null)) {
2467                 mUserStart = sysCpu[0] + sysCpu[1];
2468                 mSystemStart = sysCpu[2];
2469                 mIdleStart = sysCpu[3];
2470                 mIrqStart = sysCpu[4] + sysCpu[5] + sysCpu[6];
2471             }
2472             mUiStart = SystemClock.currentThreadTimeMillis();
2473         }
2474     }
2475
2476     void onPageFinished(WebView view, String url) {
2477         // Reset the title and icon in case we stopped a provisional load.
2478         resetTitleAndIcon(view);
2479         // Update the lock icon image only once we are done loading
2480         updateLockIconToLatest();
2481         // pause the WebView timer and release the wake lock if it is finished
2482         // while BrowserActivity is in pause state.
2483         if (mActivityInPause && pauseWebViewTimers()) {
2484             if (mWakeLock.isHeld()) {
2485                 mHandler.removeMessages(RELEASE_WAKELOCK);
2486                 mWakeLock.release();
2487             }
2488         }
2489
2490         // Performance probe
2491         if (false) {
2492             long[] sysCpu = new long[7];
2493             if (Process.readProcFile("/proc/stat", SYSTEM_CPU_FORMAT, null,
2494                     sysCpu, null)) {
2495                 String uiInfo = "UI thread used "
2496                         + (SystemClock.currentThreadTimeMillis() - mUiStart)
2497                         + " ms";
2498                 if (LOGD_ENABLED) {
2499                     Log.d(LOGTAG, uiInfo);
2500                 }
2501                 //The string that gets written to the log
2502                 String performanceString = "It took total "
2503                         + (SystemClock.uptimeMillis() - mStart)
2504                         + " ms clock time to load the page."
2505                         + "\nbrowser process used "
2506                         + (Process.getElapsedCpuTime() - mProcessStart)
2507                         + " ms, user processes used "
2508                         + (sysCpu[0] + sysCpu[1] - mUserStart) * 10
2509                         + " ms, kernel used "
2510                         + (sysCpu[2] - mSystemStart) * 10
2511                         + " ms, idle took " + (sysCpu[3] - mIdleStart) * 10
2512                         + " ms and irq took "
2513                         + (sysCpu[4] + sysCpu[5] + sysCpu[6] - mIrqStart)
2514                         * 10 + " ms, " + uiInfo;
2515                 if (LOGD_ENABLED) {
2516                     Log.d(LOGTAG, performanceString + "\nWebpage: " + url);
2517                 }
2518                 if (url != null) {
2519                     // strip the url to maintain consistency
2520                     String newUrl = new String(url);
2521                     if (newUrl.startsWith("http://www.")) {
2522                         newUrl = newUrl.substring(11);
2523                     } else if (newUrl.startsWith("http://")) {
2524                         newUrl = newUrl.substring(7);
2525                     } else if (newUrl.startsWith("https://www.")) {
2526                         newUrl = newUrl.substring(12);
2527                     } else if (newUrl.startsWith("https://")) {
2528                         newUrl = newUrl.substring(8);
2529                     }
2530                     if (LOGD_ENABLED) {
2531                         Log.d(LOGTAG, newUrl + " loaded");
2532                     }
2533                 }
2534             }
2535          }
2536
2537         if (mInTrace) {
2538             mInTrace = false;
2539             Debug.stopMethodTracing();
2540         }
2541     }
2542
2543     boolean shouldOverrideUrlLoading(WebView view, String url) {
2544         if (url.startsWith(SCHEME_WTAI)) {
2545             // wtai://wp/mc;number
2546             // number=string(phone-number)
2547             if (url.startsWith(SCHEME_WTAI_MC)) {
2548                 Intent intent = new Intent(Intent.ACTION_VIEW,
2549                         Uri.parse(WebView.SCHEME_TEL +
2550                         url.substring(SCHEME_WTAI_MC.length())));
2551                 startActivity(intent);
2552                 return true;
2553             }
2554             // wtai://wp/sd;dtmf
2555             // dtmf=string(dialstring)
2556             if (url.startsWith(SCHEME_WTAI_SD)) {
2557                 // TODO: only send when there is active voice connection
2558                 return false;
2559             }
2560             // wtai://wp/ap;number;name
2561             // number=string(phone-number)
2562             // name=string
2563             if (url.startsWith(SCHEME_WTAI_AP)) {
2564                 // TODO
2565                 return false;
2566             }
2567         }
2568
2569         // The "about:" schemes are internal to the browser; don't want these to
2570         // be dispatched to other apps.
2571         if (url.startsWith("about:")) {
2572             return false;
2573         }
2574
2575         Intent intent;
2576         // perform generic parsing of the URI to turn it into an Intent.
2577         try {
2578             intent = Intent.parseUri(url, Intent.URI_INTENT_SCHEME);
2579         } catch (URISyntaxException ex) {
2580             Log.w("Browser", "Bad URI " + url + ": " + ex.getMessage());
2581             return false;
2582         }
2583
2584         // check whether the intent can be resolved. If not, we will see
2585         // whether we can download it from the Market.
2586         if (getPackageManager().resolveActivity(intent, 0) == null) {
2587             String packagename = intent.getPackage();
2588             if (packagename != null) {
2589                 intent = new Intent(Intent.ACTION_VIEW, Uri
2590                         .parse("market://search?q=pname:" + packagename));
2591                 intent.addCategory(Intent.CATEGORY_BROWSABLE);
2592                 startActivity(intent);
2593                 return true;
2594             } else {
2595                 return false;
2596             }
2597         }
2598
2599         // sanitize the Intent, ensuring web pages can not bypass browser
2600         // security (only access to BROWSABLE activities).
2601         intent.addCategory(Intent.CATEGORY_BROWSABLE);
2602         intent.setComponent(null);
2603         try {
2604             if (startActivityIfNeeded(intent, -1)) {
2605                 return true;
2606             }
2607         } catch (ActivityNotFoundException ex) {
2608             // ignore the error. If no application can handle the URL,
2609             // eg about:blank, assume the browser can handle it.
2610         }
2611
2612         if (mMenuIsDown) {
2613             openTab(url);
2614             closeOptionsMenu();
2615             return true;
2616         }
2617         return false;
2618     }
2619
2620     // -------------------------------------------------------------------------
2621     // Helper function for WebChromeClient
2622     // -------------------------------------------------------------------------
2623
2624     void onProgressChanged(WebView view, int newProgress) {
2625         mFakeTitleBar.setProgress(newProgress);
2626
2627         if (newProgress == 100) {
2628             // onProgressChanged() may continue to be called after the main
2629             // frame has finished loading, as any remaining sub frames continue
2630             // to load. We'll only get called once though with newProgress as
2631             // 100 when everything is loaded. (onPageFinished is called once
2632             // when the main frame completes loading regardless of the state of
2633             // any sub frames so calls to onProgressChanges may continue after
2634             // onPageFinished has executed)
2635             if (mInLoad) {
2636                 mInLoad = false;
2637                 updateInLoadMenuItems();
2638                 // If the options menu is open, leave the title bar
2639                 if (!mOptionsMenuOpen || !mIconView) {
2640                     hideFakeTitleBar();
2641                 }
2642             }
2643         } else {
2644             if (!mInLoad) {
2645                 // onPageFinished may have already been called but a subframe is
2646                 // still loading and updating the progress. Reset mInLoad and
2647                 // update the menu items.
2648                 mInLoad = true;
2649                 updateInLoadMenuItems();
2650             }
2651             // When the page first begins to load, the Activity may still be
2652             // paused, in which case showFakeTitleBar will do nothing.  Call
2653             // again as the page continues to load so that it will be shown.
2654             // (Calling it will the fake title bar is already showing will also
2655             // do nothing.
2656             if (!mOptionsMenuOpen || mIconView) {
2657                 // This page has begun to load, so show the title bar
2658                 showFakeTitleBar();
2659             }
2660         }
2661     }
2662
2663     void onShowCustomView(View view, WebChromeClient.CustomViewCallback callback) {
2664         // if a view already exists then immediately terminate the new one
2665         if (mCustomView != null) {
2666             callback.onCustomViewHidden();
2667             return;
2668         }
2669
2670         // Add the custom view to its container.
2671         mCustomViewContainer.addView(view, COVER_SCREEN_GRAVITY_CENTER);
2672         mCustomView = view;
2673         mCustomViewCallback = callback;
2674         // Save the menu state and set it to empty while the custom
2675         // view is showing.
2676         mOldMenuState = mMenuState;
2677         mMenuState = EMPTY_MENU;
2678         // Hide the content view.
2679         mContentView.setVisibility(View.GONE);
2680         // Finally show the custom view container.
2681         setStatusBarVisibility(false);
2682         mCustomViewContainer.setVisibility(View.VISIBLE);
2683         mCustomViewContainer.bringToFront();
2684     }
2685
2686     void onHideCustomView() {
2687         if (mCustomView == null)
2688             return;
2689
2690         // Hide the custom view.
2691         mCustomView.setVisibility(View.GONE);
2692         // Remove the custom view from its container.
2693         mCustomViewContainer.removeView(mCustomView);
2694         mCustomView = null;
2695         // Reset the old menu state.
2696         mMenuState = mOldMenuState;
2697         mOldMenuState = EMPTY_MENU;
2698         mCustomViewContainer.setVisibility(View.GONE);
2699         mCustomViewCallback.onCustomViewHidden();
2700         // Show the content view.
2701         setStatusBarVisibility(true);
2702         mContentView.setVisibility(View.VISIBLE);
2703     }
2704
2705     Bitmap getDefaultVideoPoster() {
2706         if (mDefaultVideoPoster == null) {
2707             mDefaultVideoPoster = BitmapFactory.decodeResource(
2708                     getResources(), R.drawable.default_video_poster);
2709         }
2710         return mDefaultVideoPoster;
2711     }
2712
2713     View getVideoLoadingProgressView() {
2714         if (mVideoProgressView == null) {
2715             LayoutInflater inflater = LayoutInflater.from(BrowserActivity.this);
2716             mVideoProgressView = inflater.inflate(
2717                     R.layout.video_loading_progress, null);
2718         }
2719         return mVideoProgressView;
2720     }
2721
2722     /*
2723      * The Object used to inform the WebView of the file to upload.
2724      */
2725     private ValueCallback<Uri> mUploadMessage;
2726
2727     void openFileChooser(ValueCallback<Uri> uploadMsg) {
2728         if (mUploadMessage != null) return;
2729         mUploadMessage = uploadMsg;
2730         Intent i = new Intent(Intent.ACTION_GET_CONTENT);
2731         i.addCategory(Intent.CATEGORY_OPENABLE);
2732         i.setType("*/*");
2733         BrowserActivity.this.startActivityForResult(Intent.createChooser(i,
2734                 getString(R.string.choose_upload)), FILE_SELECTED);
2735     }
2736
2737     // -------------------------------------------------------------------------
2738     // Implement functions for DownloadListener
2739     // -------------------------------------------------------------------------
2740
2741     /**
2742      * Notify the host application a download should be done, or that
2743      * the data should be streamed if a streaming viewer is available.
2744      * @param url The full url to the content that should be downloaded
2745      * @param contentDisposition Content-disposition http header, if
2746      *                           present.
2747      * @param mimetype The mimetype of the content reported by the server
2748      * @param contentLength The file size reported by the server
2749      */
2750     public void onDownloadStart(String url, String userAgent,
2751             String contentDisposition, String mimetype, long contentLength) {
2752         // if we're dealing wih A/V content that's not explicitly marked
2753         //     for download, check if it's streamable.
2754         if (contentDisposition == null
2755                 || !contentDisposition.regionMatches(
2756                         true, 0, "attachment", 0, 10)) {
2757             // query the package manager to see if there's a registered handler
2758             //     that matches.
2759             Intent intent = new Intent(Intent.ACTION_VIEW);
2760             intent.setDataAndType(Uri.parse(url), mimetype);
2761             ResolveInfo info = getPackageManager().resolveActivity(intent,
2762                     PackageManager.MATCH_DEFAULT_ONLY);
2763             if (info != null) {
2764                 ComponentName myName = getComponentName();
2765                 // If we resolved to ourselves, we don't want to attempt to
2766                 // load the url only to try and download it again.
2767                 if (!myName.getPackageName().equals(
2768                         info.activityInfo.packageName)
2769                         || !myName.getClassName().equals(
2770                                 info.activityInfo.name)) {
2771                     // someone (other than us) knows how to handle this mime
2772                     // type with this scheme, don't download.
2773                     try {
2774                         startActivity(intent);
2775                         return;
2776                     } catch (ActivityNotFoundException ex) {
2777                         if (LOGD_ENABLED) {
2778                             Log.d(LOGTAG, "activity not found for " + mimetype
2779                                     + " over " + Uri.parse(url).getScheme(),
2780                                     ex);
2781                         }
2782                         // Best behavior is to fall back to a download in this
2783                         // case
2784                     }
2785                 }
2786             }
2787         }
2788         onDownloadStartNoStream(url, userAgent, contentDisposition, mimetype, contentLength);
2789     }
2790
2791     // This is to work around the fact that java.net.URI throws Exceptions
2792     // instead of just encoding URL's properly
2793     // Helper method for onDownloadStartNoStream
2794     private static String encodePath(String path) {
2795         char[] chars = path.toCharArray();
2796
2797         boolean needed = false;
2798         for (char c : chars) {
2799             if (c == '[' || c == ']') {
2800                 needed = true;
2801                 break;
2802             }
2803         }
2804         if (needed == false) {
2805             return path;
2806         }
2807
2808         StringBuilder sb = new StringBuilder("");
2809         for (char c : chars) {
2810             if (c == '[' || c == ']') {
2811                 sb.append('%');
2812                 sb.append(Integer.toHexString(c));
2813             } else {
2814                 sb.append(c);
2815             }
2816         }
2817
2818         return sb.toString();
2819     }
2820
2821     /**
2822      * Notify the host application a download should be done, even if there
2823      * is a streaming viewer available for thise type.
2824      * @param url The full url to the content that should be downloaded
2825      * @param contentDisposition Content-disposition http header, if
2826      *                           present.
2827      * @param mimetype The mimetype of the content reported by the server
2828      * @param contentLength The file size reported by the server
2829      */
2830     /*package */ void onDownloadStartNoStream(String url, String userAgent,
2831             String contentDisposition, String mimetype, long contentLength) {
2832
2833         String filename = URLUtil.guessFileName(url,
2834                 contentDisposition, mimetype);
2835
2836         // Check to see if we have an SDCard
2837         String status = Environment.getExternalStorageState();
2838         if (!status.equals(Environment.MEDIA_MOUNTED)) {
2839             int title;
2840             String msg;
2841
2842             // Check to see if the SDCard is busy, same as the music app
2843             if (status.equals(Environment.MEDIA_SHARED)) {
2844                 msg = getString(R.string.download_sdcard_busy_dlg_msg);
2845                 title = R.string.download_sdcard_busy_dlg_title;
2846             } else {
2847                 msg = getString(R.string.download_no_sdcard_dlg_msg, filename);
2848                 title = R.string.download_no_sdcard_dlg_title;
2849             }
2850
2851             new AlertDialog.Builder(this)
2852                 .setTitle(title)
2853                 .setIcon(android.R.drawable.ic_dialog_alert)
2854                 .setMessage(msg)
2855                 .setPositiveButton(R.string.ok, null)
2856                 .show();
2857             return;
2858         }
2859
2860         // java.net.URI is a lot stricter than KURL so we have to encode some
2861         // extra characters. Fix for b 2538060 and b 1634719
2862         WebAddress webAddress;
2863         try {
2864             webAddress = new WebAddress(url);
2865             webAddress.mPath = encodePath(webAddress.mPath);
2866         } catch (Exception e) {
2867             // This only happens for very bad urls, we want to chatch the
2868             // exception here
2869             Log.e(LOGTAG, "Exception trying to parse url:" + url);
2870             return;
2871         }
2872
2873         // XXX: Have to use the old url since the cookies were stored using the
2874         // old percent-encoded url.
2875         String cookies = CookieManager.getInstance().getCookie(url);
2876
2877         ContentValues values = new ContentValues();
2878         values.put(Downloads.Impl.COLUMN_URI, webAddress.toString());
2879         values.put(Downloads.Impl.COLUMN_COOKIE_DATA, cookies);
2880         values.put(Downloads.Impl.COLUMN_USER_AGENT, userAgent);
2881         values.put(Downloads.Impl.COLUMN_NOTIFICATION_PACKAGE,
2882                 getPackageName());
2883         values.put(Downloads.Impl.COLUMN_NOTIFICATION_CLASS,
2884                 BrowserDownloadPage.class.getCanonicalName());
2885         values.put(Downloads.Impl.COLUMN_VISIBILITY,
2886                 Downloads.Impl.VISIBILITY_VISIBLE_NOTIFY_COMPLETED);
2887         values.put(Downloads.Impl.COLUMN_MIME_TYPE, mimetype);
2888         values.put(Downloads.Impl.COLUMN_FILE_NAME_HINT, filename);
2889         values.put(Downloads.Impl.COLUMN_DESCRIPTION, webAddress.mHost);
2890         if (contentLength > 0) {
2891             values.put(Downloads.Impl.COLUMN_TOTAL_BYTES, contentLength);
2892         }
2893         if (mimetype == null) {
2894             // We must have long pressed on a link or image to download it. We
2895             // are not sure of the mimetype in this case, so do a head request
2896             new FetchUrlMimeType(this).execute(values);
2897         } else {
2898             final Uri contentUri =
2899                     getContentResolver().insert(Downloads.Impl.CONTENT_URI, values);
2900         }
2901         Toast.makeText(this, R.string.download_pending, Toast.LENGTH_SHORT)
2902                 .show();
2903     }
2904
2905     // -------------------------------------------------------------------------
2906
2907     /**
2908      * Resets the lock icon. This method is called when we start a new load and
2909      * know the url to be loaded.
2910      */
2911     private void resetLockIcon(String url) {
2912         // Save the lock-icon state (we revert to it if the load gets cancelled)
2913         mTabControl.getCurrentTab().resetLockIcon(url);
2914         updateLockIconImage(LOCK_ICON_UNSECURE);
2915     }
2916
2917     /**
2918      * Update the lock icon to correspond to our latest state.
2919      */
2920     private void updateLockIconToLatest() {
2921         updateLockIconImage(mTabControl.getCurrentTab().getLockIconType());
2922     }
2923
2924     /**
2925      * Updates the lock-icon image in the title-bar.
2926      */
2927     private void updateLockIconImage(int lockIconType) {
2928         Drawable d = null;
2929         if (lockIconType == LOCK_ICON_SECURE) {
2930             d = mSecLockIcon;
2931         } else if (lockIconType == LOCK_ICON_MIXED) {
2932             d = mMixLockIcon;
2933         }
2934         mTitleBar.setLock(d);
2935         mFakeTitleBar.setLock(d);
2936     }
2937
2938     /**
2939      * Displays a page-info dialog.
2940      * @param tab The tab to show info about
2941      * @param fromShowSSLCertificateOnError The flag that indicates whether
2942      * this dialog was opened from the SSL-certificate-on-error dialog or
2943      * not. This is important, since we need to know whether to return to
2944      * the parent dialog or simply dismiss.
2945      */
2946     private void showPageInfo(final Tab tab,
2947                               final boolean fromShowSSLCertificateOnError) {
2948         final LayoutInflater factory = LayoutInflater
2949                 .from(this);
2950
2951         final View pageInfoView = factory.inflate(R.layout.page_info, null);
2952
2953         final WebView view = tab.getWebView();
2954
2955         String url = null;
2956         String title = null;
2957
2958         if (view == null) {
2959             url = tab.getUrl();
2960             title = tab.getTitle();
2961         } else if (view == mTabControl.getCurrentWebView()) {
2962              // Use the cached title and url if this is the current WebView
2963             url = mUrl;
2964             title = mTitle;
2965         } else {
2966             url = view.getUrl();
2967             title = view.getTitle();
2968         }
2969
2970         if (url == null) {
2971             url = "";
2972         }
2973         if (title == null) {
2974             title = "";
2975         }
2976
2977         ((TextView) pageInfoView.findViewById(R.id.address)).setText(url);
2978         ((TextView) pageInfoView.findViewById(R.id.title)).setText(title);
2979
2980         mPageInfoView = tab;
2981         mPageInfoFromShowSSLCertificateOnError = fromShowSSLCertificateOnError;
2982
2983         AlertDialog.Builder alertDialogBuilder =
2984             new AlertDialog.Builder(this)
2985             .setTitle(R.string.page_info).setIcon(android.R.drawable.ic_dialog_info)
2986             .setView(pageInfoView)
2987             .setPositiveButton(
2988                 R.string.ok,
2989                 new DialogInterface.OnClickListener() {
2990                     public void onClick(DialogInterface dialog,
2991                                         int whichButton) {
2992                         mPageInfoDialog = null;
2993                         mPageInfoView = null;
2994
2995                         // if we came here from the SSL error dialog
2996                         if (fromShowSSLCertificateOnError) {
2997                             // go back to the SSL error dialog
2998                             showSSLCertificateOnError(
2999                                 mSSLCertificateOnErrorView,
3000                                 mSSLCertificateOnErrorHandler,
3001                                 mSSLCertificateOnErrorError);
3002                         }
3003                     }
3004                 })
3005             .setOnCancelListener(
3006                 new DialogInterface.OnCancelListener() {
3007                     public void onCancel(DialogInterface dialog) {
3008                         mPageInfoDialog = null;
3009                         mPageInfoView = null;
3010
3011                         // if we came here from the SSL error dialog
3012                         if (fromShowSSLCertificateOnError) {
3013                             // go back to the SSL error dialog
3014                             showSSLCertificateOnError(
3015                                 mSSLCertificateOnErrorView,
3016                                 mSSLCertificateOnErrorHandler,
3017                                 mSSLCertificateOnErrorError);
3018                         }
3019                     }
3020                 });
3021
3022         // if we have a main top-level page SSL certificate set or a certificate
3023         // error
3024         if (fromShowSSLCertificateOnError ||
3025                 (view != null && view.getCertificate() != null)) {
3026             // add a 'View Certificate' button
3027             alertDialogBuilder.setNeutralButton(
3028                 R.string.view_certificate,
3029                 new DialogInterface.OnClickListener() {
3030                     public void onClick(DialogInterface dialog,
3031                                         int whichButton) {
3032                         mPageInfoDialog = null;
3033                         mPageInfoView = null;
3034
3035                         // if we came here from the SSL error dialog
3036                         if (fromShowSSLCertificateOnError) {
3037                             // go back to the SSL error dialog
3038                             showSSLCertificateOnError(
3039                                 mSSLCertificateOnErrorView,
3040                                 mSSLCertificateOnErrorHandler,
3041                                 mSSLCertificateOnErrorError);
3042                         } else {
3043                             // otherwise, display the top-most certificate from
3044                             // the chain
3045                             if (view.getCertificate() != null) {
3046                                 showSSLCertificate(tab);
3047                             }
3048                         }
3049                     }
3050                 });
3051         }
3052
3053         mPageInfoDialog = alertDialogBuilder.show();
3054     }
3055
3056        /**
3057      * Displays the main top-level page SSL certificate dialog
3058      * (accessible from the Page-Info dialog).
3059      * @param tab The tab to show certificate for.
3060      */
3061     private void showSSLCertificate(final Tab tab) {
3062         final View certificateView =
3063                 inflateCertificateView(tab.getWebView().getCertificate());
3064         if (certificateView == null) {
3065             return;
3066         }
3067
3068         LayoutInflater factory = LayoutInflater.from(this);
3069
3070         final LinearLayout placeholder =
3071                 (LinearLayout)certificateView.findViewById(R.id.placeholder);
3072
3073         LinearLayout ll = (LinearLayout) factory.inflate(
3074             R.layout.ssl_success, placeholder);
3075         ((TextView)ll.findViewById(R.id.success))
3076             .setText(R.string.ssl_certificate_is_valid);
3077
3078         mSSLCertificateView = tab;
3079         mSSLCertificateDialog =
3080             new AlertDialog.Builder(this)
3081                 .setTitle(R.string.ssl_certificate).setIcon(
3082                     R.drawable.ic_dialog_browser_certificate_secure)
3083                 .setView(certificateView)
3084                 .setPositiveButton(R.string.ok,
3085                         new DialogInterface.OnClickListener() {
3086                             public void onClick(DialogInterface dialog,
3087                                     int whichButton) {
3088                                 mSSLCertificateDialog = null;
3089                                 mSSLCertificateView = null;
3090
3091                                 showPageInfo(tab, false);
3092                             }
3093                         })
3094                 .setOnCancelListener(
3095                         new DialogInterface.OnCancelListener() {
3096                             public void onCancel(DialogInterface dialog) {
3097                                 mSSLCertificateDialog = null;
3098                                 mSSLCertificateView = null;
3099
3100                                 showPageInfo(tab, false);
3101                             }
3102                         })
3103                 .show();
3104     }
3105
3106     /**
3107      * Displays the SSL error certificate dialog.
3108      * @param view The target web-view.
3109      * @param handler The SSL error handler responsible for cancelling the
3110      * connection that resulted in an SSL error or proceeding per user request.
3111      * @param error The SSL error object.
3112      */
3113     void showSSLCertificateOnError(
3114         final WebView view, final SslErrorHandler handler, final SslError error) {
3115
3116         final View certificateView =
3117             inflateCertificateView(error.getCertificate());
3118         if (certificateView == null) {
3119             return;
3120         }
3121
3122         LayoutInflater factory = LayoutInflater.from(this);
3123
3124         final LinearLayout placeholder =
3125                 (LinearLayout)certificateView.findViewById(R.id.placeholder);
3126
3127         if (error.hasError(SslError.SSL_UNTRUSTED)) {
3128             LinearLayout ll = (LinearLayout)factory
3129                 .inflate(R.layout.ssl_warning, placeholder);
3130             ((TextView)ll.findViewById(R.id.warning))
3131                 .setText(R.string.ssl_untrusted);
3132         }
3133
3134         if (error.hasError(SslError.SSL_IDMISMATCH)) {
3135             LinearLayout ll = (LinearLayout)factory
3136                 .inflate(R.layout.ssl_warning, placeholder);
3137             ((TextView)ll.findViewById(R.id.warning))
3138                 .setText(R.string.ssl_mismatch);
3139         }
3140
3141         if (error.hasError(SslError.SSL_EXPIRED)) {
3142             LinearLayout ll = (LinearLayout)factory
3143                 .inflate(R.layout.ssl_warning, placeholder);
3144             ((TextView)ll.findViewById(R.id.warning))
3145                 .setText(R.string.ssl_expired);
3146         }
3147
3148         if (error.hasError(SslError.SSL_NOTYETVALID)) {
3149             LinearLayout ll = (LinearLayout)factory
3150                 .inflate(R.layout.ssl_warning, placeholder);
3151             ((TextView)ll.findViewById(R.id.warning))
3152                 .setText(R.string.ssl_not_yet_valid);
3153         }
3154
3155         mSSLCertificateOnErrorHandler = handler;
3156         mSSLCertificateOnErrorView = view;
3157         mSSLCertificateOnErrorError = error;
3158         mSSLCertificateOnErrorDialog =
3159             new AlertDialog.Builder(this)
3160                 .setTitle(R.string.ssl_certificate).setIcon(
3161                     R.drawable.ic_dialog_browser_certificate_partially_secure)
3162                 .setView(certificateView)
3163                 .setPositiveButton(R.string.ok,
3164                         new DialogInterface.OnClickListener() {
3165                             public void onClick(DialogInterface dialog,
3166                                     int whichButton) {
3167                                 mSSLCertificateOnErrorDialog = null;
3168                                 mSSLCertificateOnErrorView = null;
3169                                 mSSLCertificateOnErrorHandler = null;
3170                                 mSSLCertificateOnErrorError = null;
3171
3172                                 view.getWebViewClient().onReceivedSslError(
3173                                                 view, handler, error);
3174                             }
3175                         })
3176                  .setNeutralButton(R.string.page_info_view,
3177                         new DialogInterface.OnClickListener() {
3178                             public void onClick(DialogInterface dialog,
3179                                     int whichButton) {
3180                                 mSSLCertificateOnErrorDialog = null;
3181
3182                                 // do not clear the dialog state: we will
3183                                 // need to show the dialog again once the
3184                                 // user is done exploring the page-info details
3185
3186                                 showPageInfo(mTabControl.getTabFromView(view),
3187                                         true);
3188                             }
3189                         })
3190                 .setOnCancelListener(
3191                         new DialogInterface.OnCancelListener() {
3192                             public void onCancel(DialogInterface dialog) {
3193                                 mSSLCertificateOnErrorDialog = null;
3194                                 mSSLCertificateOnErrorView = null;
3195                                 mSSLCertificateOnErrorHandler = null;
3196                                 mSSLCertificateOnErrorError = null;
3197
3198                                 view.getWebViewClient().onReceivedSslError(
3199                                                 view, handler, error);
3200                             }
3201                         })
3202                 .show();
3203     }
3204
3205     /**
3206      * Inflates the SSL certificate view (helper method).
3207      * @param certificate The SSL certificate.
3208      * @return The resultant certificate view with issued-to, issued-by,
3209      * issued-on, expires-on, and possibly other fields set.
3210      * If the input certificate is null, returns null.
3211      */
3212     private View inflateCertificateView(SslCertificate certificate) {
3213         if (certificate == null) {
3214             return null;
3215         }
3216
3217         LayoutInflater factory = LayoutInflater.from(this);
3218
3219         View certificateView = factory.inflate(
3220             R.layout.ssl_certificate, null);
3221
3222         // issued to:
3223         SslCertificate.DName issuedTo = certificate.getIssuedTo();
3224         if (issuedTo != null) {
3225             ((TextView) certificateView.findViewById(R.id.to_common))
3226                 .setText(issuedTo.getCName());
3227             ((TextView) certificateView.findViewById(R.id.to_org))
3228                 .setText(issuedTo.getOName());
3229             ((TextView) certificateView.findViewById(R.id.to_org_unit))
3230                 .setText(issuedTo.getUName());
3231         }
3232
3233         // issued by:
3234         SslCertificate.DName issuedBy = certificate.getIssuedBy();
3235         if (issuedBy != null) {
3236             ((TextView) certificateView.findViewById(R.id.by_common))
3237                 .setText(issuedBy.getCName());
3238             ((TextView) certificateView.findViewById(R.id.by_org))
3239                 .setText(issuedBy.getOName());
3240             ((TextView) certificateView.findViewById(R.id.by_org_unit))
3241                 .setText(issuedBy.getUName());
3242         }
3243
3244         // issued on:
3245         String issuedOn = formatCertificateDate(
3246             certificate.getValidNotBeforeDate());
3247         ((TextView) certificateView.findViewById(R.id.issued_on))
3248             .setText(issuedOn);
3249
3250         // expires on:
3251         String expiresOn = formatCertificateDate(
3252             certificate.getValidNotAfterDate());
3253         ((TextView) certificateView.findViewById(R.id.expires_on))
3254             .setText(expiresOn);
3255
3256         return certificateView;
3257     }
3258
3259     /**
3260      * Formats the certificate date to a properly localized date string.
3261      * @return Properly localized version of the certificate date string and
3262      * the "" if it fails to localize.
3263      */
3264     private String formatCertificateDate(Date certificateDate) {
3265       if (certificateDate == null) {
3266           return "";
3267       }
3268       String formattedDate = DateFormat.getDateFormat(this).format(certificateDate);
3269       if (formattedDate == null) {
3270           return "";
3271       }
3272       return formattedDate;
3273     }
3274
3275     /**
3276      * Displays an http-authentication dialog.
3277      */
3278     void showHttpAuthentication(final HttpAuthHandler handler,
3279             final String host, final String realm, final String title,
3280             final String name, final String password, int focusId) {
3281         LayoutInflater factory = LayoutInflater.from(this);
3282         final View v = factory
3283                 .inflate(R.layout.http_authentication, null);
3284         if (name != null) {
3285             ((EditText) v.findViewById(R.id.username_edit)).setText(name);
3286         }
3287         if (password != null) {
3288             ((EditText) v.findViewById(R.id.password_edit)).setText(password);
3289         }
3290
3291         String titleText = title;
3292         if (titleText == null) {
3293             titleText = getText(R.string.sign_in_to).toString().replace(
3294                     "%s1", host).replace("%s2", realm);
3295         }
3296
3297         mHttpAuthHandler = handler;
3298         AlertDialog dialog = new AlertDialog.Builder(this)
3299                 .setTitle(titleText)
3300                 .setIcon(android.R.drawable.ic_dialog_alert)
3301                 .setView(v)
3302                 .setPositiveButton(R.string.action,
3303                         new DialogInterface.OnClickListener() {
3304                              public void onClick(DialogInterface dialog,
3305                                      int whichButton) {
3306                                 String nm = ((EditText) v
3307                                         .findViewById(R.id.username_edit))
3308                                         .getText().toString();
3309                                 String pw = ((EditText) v
3310                                         .findViewById(R.id.password_edit))
3311                                         .getText().toString();
3312                                 BrowserActivity.this.setHttpAuthUsernamePassword
3313                                         (host, realm, nm, pw);
3314                                 handler.proceed(nm, pw);
3315                                 mHttpAuthenticationDialog = null;
3316                                 mHttpAuthHandler = null;
3317                             }})
3318                 .setNegativeButton(R.string.cancel,
3319                         new DialogInterface.OnClickListener() {
3320                             public void onClick(DialogInterface dialog,
3321                                     int whichButton) {
3322                                 handler.cancel();
3323                                 BrowserActivity.this.resetTitleAndRevertLockIcon();
3324                                 mHttpAuthenticationDialog = null;
3325                                 mHttpAuthHandler = null;
3326                             }})
3327                 .setOnCancelListener(new DialogInterface.OnCancelListener() {
3328                         public void onCancel(DialogInterface dialog) {
3329                             handler.cancel();
3330                             BrowserActivity.this.resetTitleAndRevertLockIcon();
3331                             mHttpAuthenticationDialog = null;
3332                             mHttpAuthHandler = null;
3333                         }})
3334                 .create();
3335         // Make the IME appear when the dialog is displayed if applicable.
3336         dialog.getWindow().setSoftInputMode(
3337                 WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE);
3338         dialog.show();
3339         if (focusId != 0) {
3340             dialog.findViewById(focusId).requestFocus();
3341         } else {
3342             v.findViewById(R.id.username_edit).requestFocus();
3343         }
3344         mHttpAuthenticationDialog = dialog;
3345     }
3346
3347     public int getProgress() {
3348         WebView w = mTabControl.getCurrentWebView();
3349         if (w != null) {
3350             return w.getProgress();
3351         } else {
3352             return 100;
3353         }
3354     }
3355
3356     /**
3357      * Set HTTP authentication password.
3358      *
3359      * @param host The host for the password
3360      * @param realm The realm for the password
3361      * @param username The username for the password. If it is null, it means
3362      *            password can't be saved.
3363      * @param password The password
3364      */
3365     public void setHttpAuthUsernamePassword(String host, String realm,
3366                                             String username,
3367                                             String password) {
3368         WebView w = getTopWindow();
3369         if (w != null) {
3370             w.setHttpAuthUsernamePassword(host, realm, username, password);
3371         }
3372     }
3373
3374     /**
3375      * connectivity manager says net has come or gone... inform the user
3376      * @param up true if net has come up, false if net has gone down
3377      */
3378     public void onNetworkToggle(boolean up) {
3379         if (up == mIsNetworkUp) {
3380             return;
3381         } else if (up) {
3382             mIsNetworkUp = true;
3383             if (mAlertDialog != null) {
3384                 mAlertDialog.cancel();
3385                 mAlertDialog = null;
3386             }
3387         } else {
3388             mIsNetworkUp = false;
3389             if (mInLoad) {
3390                 createAndShowNetworkDialog();
3391            }
3392         }
3393         WebView w = mTabControl.getCurrentWebView();
3394         if (w != null) {
3395             w.setNetworkAvailable(up);
3396         }
3397     }
3398
3399     boolean isNetworkUp() {
3400         return mIsNetworkUp;
3401     }
3402
3403     // This method shows the network dialog alerting the user that the net is
3404     // down. It will only show the dialog if mAlertDialog is null.
3405     private void createAndShowNetworkDialog() {
3406         if (mAlertDialog == null) {
3407             mAlertDialog = new AlertDialog.Builder(this)
3408                     .setTitle(R.string.loadSuspendedTitle)
3409                     .setMessage(R.string.loadSuspended)
3410                     .setPositiveButton(R.string.ok, null)
3411                     .show();
3412         }
3413     }
3414
3415     @Override
3416     protected void onActivityResult(int requestCode, int resultCode,
3417                                     Intent intent) {
3418         if (getTopWindow() == null) return;
3419
3420         switch (requestCode) {
3421             case COMBO_PAGE:
3422                 if (resultCode == RESULT_OK && intent != null) {
3423                     String data = intent.getAction();
3424                     Bundle extras = intent.getExtras();
3425                     if (extras != null && extras.getBoolean("new_window", false)) {
3426                         openTab(data);
3427                     } else {
3428                         final Tab currentTab =
3429                                 mTabControl.getCurrentTab();
3430                         dismissSubWindow(currentTab);
3431                         if (data != null && data.length() != 0) {
3432                             loadUrl(getTopWindow(), data);
3433                         }
3434                     }
3435                 }
3436                 // Deliberately fall through to PREFERENCES_PAGE, since the
3437                 // same extra may be attached to the COMBO_PAGE
3438             case PREFERENCES_PAGE:
3439                 if (resultCode == RESULT_OK && intent != null) {
3440                     String action = intent.getStringExtra(Intent.EXTRA_TEXT);
3441                     if (BrowserSettings.PREF_CLEAR_HISTORY.equals(action)) {
3442                         mTabControl.removeParentChildRelationShips();
3443                     }
3444                 }
3445                 break;
3446             // Choose a file from the file picker.
3447             case FILE_SELECTED:
3448                 if (null == mUploadMessage) break;
3449                 Uri result = intent == null || resultCode != RESULT_OK ? null
3450                         : intent.getData();
3451                 mUploadMessage.onReceiveValue(result);
3452                 mUploadMessage = null;
3453                 break;
3454             default:
3455                 break;
3456         }
3457         getTopWindow().requestFocus();
3458     }
3459
3460     /*
3461      * This method is called as a result of the user selecting the options
3462      * menu to see the download window. It shows the download window on top of
3463      * the current window.
3464      */
3465     private void viewDownloads(Uri downloadRecord) {
3466         Intent intent = new Intent(this,
3467                 BrowserDownloadPage.class);
3468         intent.setData(downloadRecord);
3469         startActivityForResult(intent, BrowserActivity.DOWNLOAD_PAGE);
3470
3471     }
3472
3473     /**
3474      * Open the Go page.
3475      * @param startWithHistory If true, open starting on the history tab.
3476      *                         Otherwise, start with the bookmarks tab.
3477      */
3478     /* package */ void bookmarksOrHistoryPicker(boolean startWithHistory) {
3479         WebView current = mTabControl.getCurrentWebView();
3480         if (current == null) {
3481             return;
3482         }
3483         Intent intent = new Intent(this,
3484                 CombinedBookmarkHistoryActivity.class);
3485         String title = current.getTitle();
3486         String url = current.getUrl();
3487         Bitmap thumbnail = createScreenshot(current);
3488
3489         // Just in case the user opens bookmarks before a page finishes loading
3490         // so the current history item, and therefore the page, is null.
3491         if (null == url) {
3492             url = mLastEnteredUrl;
3493             // This can happen.
3494             if (null == url) {
3495                 url = mSettings.getHomePage();
3496             }
3497         }
3498         // In case the web page has not yet received its associated title.
3499         if (title == null) {
3500             title = url;
3501         }
3502         intent.putExtra("title", title);
3503         intent.putExtra("url", url);
3504         intent.putExtra("thumbnail", thumbnail);
3505         // Disable opening in a new window if we have maxed out the windows
3506         intent.putExtra("disable_new_window", !mTabControl.canCreateNewTab());
3507         intent.putExtra("touch_icon_url", current.getTouchIconUrl());
3508         if (startWithHistory) {
3509             intent.putExtra(CombinedBookmarkHistoryActivity.STARTING_TAB,
3510                     CombinedBookmarkHistoryActivity.HISTORY_TAB);
3511         }
3512         startActivityForResult(intent, COMBO_PAGE);
3513     }
3514
3515     // Called when loading from context menu or LOAD_URL message
3516     private void loadUrlFromContext(WebView view, String url) {
3517         // In case the user enters nothing.
3518         if (url != null && url.length() != 0 && view != null) {
3519             url = smartUrlFilter(url);
3520             if (!view.getWebViewClient().shouldOverrideUrlLoading(view, url)) {
3521                 loadUrl(view, url);
3522             }
3523         }
3524     }
3525
3526     /**
3527      * Load the URL into the given WebView and update the title bar
3528      * to reflect the new load.  Call this instead of WebView.loadUrl
3529      * directly.
3530      * @param view The WebView used to load url.
3531      * @param url The URL to load.
3532      */
3533     private void loadUrl(WebView view, String url) {
3534         updateTitleBarForNewLoad(view, url);
3535         view.loadUrl(url);
3536     }
3537
3538     /**
3539      * Load UrlData into a Tab and update the title bar to reflect the new
3540      * load.  Call this instead of UrlData.loadIn directly.
3541      * @param t The Tab used to load.
3542      * @param data The UrlData being loaded.
3543      */
3544     private void loadUrlDataIn(Tab t, UrlData data) {
3545         updateTitleBarForNewLoad(t.getWebView(), data.mUrl);
3546         data.loadIn(t);
3547     }
3548
3549     /**
3550      * If the WebView is the top window, update the title bar to reflect
3551      * loading the new URL.  i.e. set its text, clear the favicon (which
3552      * will be set once the page begins loading), and set the progress to
3553      * INITIAL_PROGRESS to show that the page has begun to load. Called
3554      * by loadUrl and loadUrlDataIn.
3555      * @param view The WebView that is starting a load.
3556      * @param url The URL that is being loaded.
3557      */
3558     private void updateTitleBarForNewLoad(WebView view, String url) {
3559         if (view == getTopWindow()) {
3560             setUrlTitle(url, null);
3561             setFavicon(null);
3562             onProgressChanged(view, INITIAL_PROGRESS);
3563         }
3564     }
3565
3566     private String smartUrlFilter(Uri inUri) {
3567         if (inUri != null) {
3568             return smartUrlFilter(inUri.toString());
3569         }
3570         return null;
3571     }
3572
3573     protected static final Pattern ACCEPTED_URI_SCHEMA = Pattern.compile(
3574             "(?i)" + // switch on case insensitive matching
3575             "(" +    // begin group for schema
3576             "(?:http|https|file):\\/\\/" +
3577             "|(?:inline|data|about|content|javascript):" +
3578             ")" +
3579             "(.*)" );
3580
3581     /**
3582      * Attempts to determine whether user input is a URL or search
3583      * terms.  Anything with a space is passed to search.
3584      *
3585      * Converts to lowercase any mistakenly uppercased schema (i.e.,
3586      * "Http://" converts to "http://"
3587      *
3588      * @return Original or modified URL
3589      *
3590      */
3591     String smartUrlFilter(String url) {
3592
3593         String inUrl = url.trim();
3594         boolean hasSpace = inUrl.indexOf(' ') != -1;
3595
3596         Matcher matcher = ACCEPTED_URI_SCHEMA.matcher(inUrl);
3597         if (matcher.matches()) {
3598             // force scheme to lowercase
3599             String scheme = matcher.group(1);
3600             String lcScheme = scheme.toLowerCase();
3601             if (!lcScheme.equals(scheme)) {
3602                 inUrl = lcScheme + matcher.group(2);
3603             }
3604             if (hasSpace) {
3605                 inUrl = inUrl.replace(" ", "%20");
3606             }
3607             return inUrl;
3608         }
3609         if (hasSpace) {
3610             // FIXME: Is this the correct place to add to searches?
3611             // what if someone else calls this function?
3612             int shortcut = parseUrlShortcut(inUrl);
3613             if (shortcut != SHORTCUT_INVALID) {
3614                 Browser.addSearchUrl(mResolver, inUrl);
3615                 String query = inUrl.substring(2);
3616                 switch (shortcut) {
3617                 case SHORTCUT_GOOGLE_SEARCH:
3618                     return URLUtil.composeSearchUrl(query, QuickSearch_G, QUERY_PLACE_HOLDER);
3619                 case SHORTCUT_WIKIPEDIA_SEARCH:
3620                     return URLUtil.composeSearchUrl(query, QuickSearch_W, QUERY_PLACE_HOLDER);
3621                 case SHORTCUT_DICTIONARY_SEARCH:
3622                     return URLUtil.composeSearchUrl(query, QuickSearch_D, QUERY_PLACE_HOLDER);
3623                 case SHORTCUT_GOOGLE_MOBILE_LOCAL_SEARCH:
3624                     // FIXME: we need location in this case
3625                     return URLUtil.composeSearchUrl(query, QuickSearch_L, QUERY_PLACE_HOLDER);
3626                 }
3627             }
3628         } else {
3629             if (Patterns.WEB_URL.matcher(inUrl).matches()) {
3630                 return URLUtil.guessUrl(inUrl);
3631             }
3632         }
3633
3634         Browser.addSearchUrl(mResolver, inUrl);
3635         return URLUtil.composeSearchUrl(inUrl, QuickSearch_G, QUERY_PLACE_HOLDER);
3636     }
3637
3638     /* package */ void setShouldShowErrorConsole(boolean flag) {
3639         if (flag == mShouldShowErrorConsole) {
3640             // Nothing to do.
3641             return;
3642         }
3643
3644         mShouldShowErrorConsole = flag;
3645
3646         ErrorConsoleView errorConsole = mTabControl.getCurrentTab()
3647                 .getErrorConsole(true);
3648
3649         if (flag) {
3650             // Setting the show state of the console will cause it's the layout to be inflated.
3651             if (errorConsole.numberOfErrors() > 0) {
3652                 errorConsole.showConsole(ErrorConsoleView.SHOW_MINIMIZED);
3653             } else {
3654                 errorConsole.showConsole(ErrorConsoleView.SHOW_NONE);
3655             }
3656
3657             // Now we can add it to the main view.
3658             mErrorConsoleContainer.addView(errorConsole,
3659                     new LinearLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,
3660                                                   ViewGroup.LayoutParams.WRAP_CONTENT));
3661         } else {
3662             mErrorConsoleContainer.removeView(errorConsole);
3663         }
3664
3665     }
3666
3667     boolean shouldShowErrorConsole() {
3668         return mShouldShowErrorConsole;
3669     }
3670
3671     private void setStatusBarVisibility(boolean visible) {
3672         int flag = visible ? 0 : WindowManager.LayoutParams.FLAG_FULLSCREEN;
3673         getWindow().setFlags(flag, WindowManager.LayoutParams.FLAG_FULLSCREEN);
3674     }
3675
3676
3677     private void sendNetworkType(String type, String subtype) {
3678         WebView w = mTabControl.getCurrentWebView();
3679         if (w != null) {
3680             w.setNetworkType(type, subtype);
3681         }
3682     }
3683
3684     private void packageChanged(String packageName, boolean wasAdded) {
3685         WebView w = mTabControl.getCurrentWebView();
3686         if (w == null) {
3687             return;
3688         }
3689
3690         if (wasAdded) {
3691             w.addPackageName(packageName);
3692         } else {
3693             w.removePackageName(packageName);
3694         }
3695     }
3696
3697     private void addPackageNames(Set<String> packageNames) {
3698         WebView w = mTabControl.getCurrentWebView();
3699         if (w == null) {
3700             return;
3701         }
3702
3703         w.addPackageNames(packageNames);
3704     }
3705
3706     private void getInstalledPackages() {
3707         AsyncTask<Void, Void, Set<String> > task =
3708             new AsyncTask<Void, Void, Set<String> >() {
3709             protected Set<String> doInBackground(Void... unused) {
3710                 Set<String> installedPackages = new HashSet<String>();
3711                 PackageManager pm = BrowserActivity.this.getPackageManager();
3712                 if (pm != null) {
3713                     List<PackageInfo> packages = pm.getInstalledPackages(0);
3714                     for (PackageInfo p : packages) {
3715                         if (BrowserActivity.this.sGoogleApps.contains(p.packageName)) {
3716                             installedPackages.add(p.packageName);
3717                         }
3718                     }
3719                 }
3720
3721                 return installedPackages;
3722             }
3723
3724             // Executes on the UI thread
3725             protected void onPostExecute(Set<String> installedPackages) {
3726                 addPackageNames(installedPackages);
3727             }
3728         };
3729         task.execute();
3730     }
3731
3732     final static int LOCK_ICON_UNSECURE = 0;
3733     final static int LOCK_ICON_SECURE   = 1;
3734     final static int LOCK_ICON_MIXED    = 2;
3735
3736     private BrowserSettings mSettings;
3737     private TabControl      mTabControl;
3738     private ContentResolver mResolver;
3739     private FrameLayout     mContentView;
3740     private View            mCustomView;
3741     private FrameLayout     mCustomViewContainer;
3742     private WebChromeClient.CustomViewCallback mCustomViewCallback;
3743
3744     // FIXME, temp address onPrepareMenu performance problem. When we move everything out of
3745     // view, we should rewrite this.
3746     private int mCurrentMenuState = 0;
3747     private int mMenuState = R.id.MAIN_MENU;
3748     private int mOldMenuState = EMPTY_MENU;
3749     private static final int EMPTY_MENU = -1;
3750     private Menu mMenu;
3751
3752     private FindDialog mFindDialog;
3753     // Used to prevent chording to result in firing two shortcuts immediately
3754     // one after another.  Fixes bug 1211714.
3755     boolean mCanChord;
3756
3757     private boolean mInLoad;
3758     private boolean mIsNetworkUp;
3759     private boolean mDidStopLoad;
3760
3761     /* package */ boolean mActivityInPause = true;
3762
3763     private boolean mMenuIsDown;
3764
3765     private static boolean mInTrace;
3766
3767     // Performance probe
3768     private static final int[] SYSTEM_CPU_FORMAT = new int[] {
3769             Process.PROC_SPACE_TERM | Process.PROC_COMBINE,
3770             Process.PROC_SPACE_TERM | Process.PROC_OUT_LONG, // 1: user time
3771             Process.PROC_SPACE_TERM | Process.PROC_OUT_LONG, // 2: nice time
3772             Process.PROC_SPACE_TERM | Process.PROC_OUT_LONG, // 3: sys time
3773             Process.PROC_SPACE_TERM | Process.PROC_OUT_LONG, // 4: idle time
3774             Process.PROC_SPACE_TERM | Process.PROC_OUT_LONG, // 5: iowait time
3775             Process.PROC_SPACE_TERM | Process.PROC_OUT_LONG, // 6: irq time
3776             Process.PROC_SPACE_TERM | Process.PROC_OUT_LONG  // 7: softirq time
3777     };
3778
3779     private long mStart;
3780     private long mProcessStart;
3781     private long mUserStart;
3782     private long mSystemStart;
3783     private long mIdleStart;
3784     private long mIrqStart;
3785
3786     private long mUiStart;
3787
3788     private Drawable    mMixLockIcon;
3789     private Drawable    mSecLockIcon;
3790
3791     /* hold a ref so we can auto-cancel if necessary */
3792     private AlertDialog mAlertDialog;
3793
3794     // The up-to-date URL and title (these can be different from those stored
3795     // in WebView, since it takes some time for the information in WebView to
3796     // get updated)
3797     private String mUrl;
3798     private String mTitle;
3799
3800     // As PageInfo has different style for landscape / portrait, we have
3801     // to re-open it when configuration changed
3802     private AlertDialog mPageInfoDialog;
3803     private Tab mPageInfoView;
3804     // If the Page-Info dialog is launched from the SSL-certificate-on-error
3805     // dialog, we should not just dismiss it, but should get back to the
3806     // SSL-certificate-on-error dialog. This flag is used to store this state
3807     private boolean mPageInfoFromShowSSLCertificateOnError;
3808
3809     // as SSLCertificateOnError has different style for landscape / portrait,
3810     // we have to re-open it when configuration changed
3811     private AlertDialog mSSLCertificateOnErrorDialog;
3812     private WebView mSSLCertificateOnErrorView;
3813     private SslErrorHandler mSSLCertificateOnErrorHandler;
3814     private SslError mSSLCertificateOnErrorError;
3815
3816     // as SSLCertificate has different style for landscape / portrait, we
3817     // have to re-open it when configuration changed
3818     private AlertDialog mSSLCertificateDialog;
3819     private Tab mSSLCertificateView;
3820
3821     // as HttpAuthentication has different style for landscape / portrait, we
3822     // have to re-open it when configuration changed
3823     private AlertDialog mHttpAuthenticationDialog;
3824     private HttpAuthHandler mHttpAuthHandler;
3825
3826     /*package*/ static final FrameLayout.LayoutParams COVER_SCREEN_PARAMS =
3827                                             new FrameLayout.LayoutParams(
3828                                             ViewGroup.LayoutParams.MATCH_PARENT,
3829                                             ViewGroup.LayoutParams.MATCH_PARENT);
3830     /*package*/ static final FrameLayout.LayoutParams COVER_SCREEN_GRAVITY_CENTER =
3831                                             new FrameLayout.LayoutParams(
3832                                             ViewGroup.LayoutParams.MATCH_PARENT,
3833                                             ViewGroup.LayoutParams.MATCH_PARENT,
3834                                             Gravity.CENTER);
3835     // Google search
3836     final static String QuickSearch_G = "http://www.google.com/m?q=%s";
3837     // Wikipedia search
3838     final static String QuickSearch_W = "http://en.wikipedia.org/w/index.php?search=%s&go=Go";
3839     // Dictionary search
3840     final static String QuickSearch_D = "http://dictionary.reference.com/search?q=%s";
3841     // Google Mobile Local search
3842     final static String QuickSearch_L = "http://www.google.com/m/search?site=local&q=%s&near=mountain+view";
3843
3844     final static String QUERY_PLACE_HOLDER = "%s";
3845
3846     // "source" parameter for Google search through search key
3847     final static String GOOGLE_SEARCH_SOURCE_SEARCHKEY = "browser-key";
3848     // "source" parameter for Google search through goto menu
3849     final static String GOOGLE_SEARCH_SOURCE_GOTO = "browser-goto";
3850     // "source" parameter for Google search through simplily type
3851     final static String GOOGLE_SEARCH_SOURCE_TYPE = "browser-type";
3852     // "source" parameter for Google search suggested by the browser
3853     final static String GOOGLE_SEARCH_SOURCE_SUGGEST = "browser-suggest";
3854     // "source" parameter for Google search from unknown source
3855     final static String GOOGLE_SEARCH_SOURCE_UNKNOWN = "unknown";
3856
3857     private final static String LOGTAG = "browser";
3858
3859     private String mLastEnteredUrl;
3860
3861     private PowerManager.WakeLock mWakeLock;
3862     private final static int WAKELOCK_TIMEOUT = 5 * 60 * 1000; // 5 minutes
3863
3864     private Toast mStopToast;
3865
3866     private TitleBar mTitleBar;
3867
3868     private LinearLayout mErrorConsoleContainer = null;
3869     private boolean mShouldShowErrorConsole = false;
3870
3871     // As the ids are dynamically created, we can't guarantee that they will
3872     // be in sequence, so this static array maps ids to a window number.
3873     final static private int[] WINDOW_SHORTCUT_ID_ARRAY =
3874     { R.id.window_one_menu_id, R.id.window_two_menu_id, R.id.window_three_menu_id,
3875       R.id.window_four_menu_id, R.id.window_five_menu_id, R.id.window_six_menu_id,
3876       R.id.window_seven_menu_id, R.id.window_eight_menu_id };
3877
3878     // monitor platform changes
3879     private IntentFilter mNetworkStateChangedFilter;
3880     private BroadcastReceiver mNetworkStateIntentReceiver;
3881
3882     private BroadcastReceiver mPackageInstallationReceiver;
3883
3884     private SystemAllowGeolocationOrigins mSystemAllowGeolocationOrigins;
3885
3886     // activity requestCode
3887     final static int COMBO_PAGE                 = 1;
3888     final static int DOWNLOAD_PAGE              = 2;
3889     final static int PREFERENCES_PAGE           = 3;
3890     final static int FILE_SELECTED              = 4;
3891
3892     // the default <video> poster
3893     private Bitmap mDefaultVideoPoster;
3894     // the video progress view
3895     private View mVideoProgressView;
3896
3897     // The Google packages we monitor for the navigator.isApplicationInstalled()
3898     // API. Add as needed.
3899     private static Set<String> sGoogleApps;
3900     static {
3901         sGoogleApps = new HashSet<String>();
3902         sGoogleApps.add("com.google.android.youtube");
3903     }
3904
3905     /**
3906      * A UrlData class to abstract how the content will be set to WebView.
3907      * This base class uses loadUrl to show the content.
3908      */
3909     /* package */ static class UrlData {
3910         final String mUrl;
3911         final Map<String, String> mHeaders;
3912         final Intent mVoiceIntent;
3913
3914         UrlData(String url) {
3915             this.mUrl = url;
3916             this.mHeaders = null;
3917             this.mVoiceIntent = null;
3918         }
3919
3920         UrlData(String url, Map<String, String> headers, Intent intent) {
3921             this.mUrl = url;
3922             this.mHeaders = headers;
3923             if (RecognizerResultsIntent.ACTION_VOICE_SEARCH_RESULTS
3924                     .equals(intent.getAction())) {
3925                 this.mVoiceIntent = intent;
3926             } else {
3927                 this.mVoiceIntent = null;
3928             }
3929         }
3930
3931         boolean isEmpty() {
3932             return mVoiceIntent == null && (mUrl == null || mUrl.length() == 0);
3933         }
3934
3935         /**
3936          * Load this UrlData into the given Tab.  Use loadUrlDataIn to update
3937          * the title bar as well.
3938          */
3939         public void loadIn(Tab t) {
3940             if (mVoiceIntent != null) {
3941                 t.activateVoiceSearchMode(mVoiceIntent);
3942             } else {
3943                 t.getWebView().loadUrl(mUrl, mHeaders);
3944             }
3945         }
3946     };
3947
3948     /* package */ static final UrlData EMPTY_URL_DATA = new UrlData(null);
3949 }