chrome/browser/android/tab_android.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/android/tab_android.h"
   6
   7 #include "base/android/jni_android.h"
   8 #include "base/android/jni_array.h"
   9 #include "base/android/jni_string.h"
  10 #include "base/metrics/histogram.h"
  11 #include "base/trace_event/trace_event.h"
  12 #include "cc/layers/layer.h"
  13 #include "chrome/browser/android/chrome_web_contents_delegate_android.h"
  14 #include "chrome/browser/android/compositor/tab_content_manager.h"
  15 #include "chrome/browser/android/metrics/uma_utils.h"
  16 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
  17 #include "chrome/browser/bookmarks/chrome_bookmark_client.h"
  18 #include "chrome/browser/bookmarks/chrome_bookmark_client_factory.h"
  19 #include "chrome/browser/browser_about_handler.h"
  20 #include "chrome/browser/chrome_notification_types.h"
  21 #include "chrome/browser/content_settings/tab_specific_content_settings.h"
  22 #include "chrome/browser/infobars/infobar_service.h"
  23 #include "chrome/browser/prerender/prerender_contents.h"
  24 #include "chrome/browser/prerender/prerender_manager.h"
  25 #include "chrome/browser/prerender/prerender_manager_factory.h"
  26 #include "chrome/browser/printing/print_view_manager_basic.h"
  27 #include "chrome/browser/profiles/profile.h"
  28 #include "chrome/browser/profiles/profile_android.h"
  29 #include "chrome/browser/search/instant_service.h"
  30 #include "chrome/browser/search/instant_service_factory.h"
  31 #include "chrome/browser/search/search.h"
  32 #include "chrome/browser/sessions/session_tab_helper.h"
  33 #include "chrome/browser/sessions/tab_restore_service.h"
  34 #include "chrome/browser/sessions/tab_restore_service_factory.h"
  35 #include "chrome/browser/sync/glue/synced_tab_delegate_android.h"
  36 #include "chrome/browser/tab_contents/tab_util.h"
  37 #include "chrome/browser/ui/android/content_settings/popup_blocked_infobar_delegate.h"
  38 #include "chrome/browser/ui/android/context_menu_helper.h"
  39 #include "chrome/browser/ui/android/infobars/infobar_container_android.h"
  40 #include "chrome/browser/ui/android/tab_model/tab_model.h"
  41 #include "chrome/browser/ui/android/tab_model/tab_model_list.h"
  42 #include "chrome/browser/ui/android/window_android_helper.h"
  43 #include "chrome/browser/ui/blocked_content/popup_blocker_tab_helper.h"
  44 #include "chrome/browser/ui/search/instant_search_prerenderer.h"
  45 #include "chrome/browser/ui/search/search_tab_helper.h"
  46 #include "chrome/browser/ui/tab_contents/core_tab_helper.h"
  47 #include "chrome/browser/ui/tab_helpers.h"
  48 #include "chrome/common/instant_types.h"
  49 #include "chrome/common/render_messages.h"
  50 #include "chrome/common/url_constants.h"
  51 #include "components/bookmarks/browser/bookmark_model.h"
  52 #include "components/bookmarks/browser/bookmark_node.h"
  53 #include "components/bookmarks/browser/bookmark_utils.h"
  54 #include "components/dom_distiller/core/url_utils.h"
  55 #include "components/favicon/content/content_favicon_driver.h"
  56 #include "components/infobars/core/infobar_container.h"
  57 #include "components/navigation_interception/intercept_navigation_delegate.h"
  58 #include "components/navigation_interception/navigation_params.h"
  59 #include "components/url_fixer/url_fixer.h"
  60 #include "content/public/browser/android/content_view_core.h"
  61 #include "content/public/browser/browser_thread.h"
  62 #include "content/public/browser/interstitial_page.h"
  63 #include "content/public/browser/navigation_entry.h"
  64 #include "content/public/browser/notification_service.h"
  65 #include "content/public/browser/render_frame_host.h"
  66 #include "content/public/browser/render_process_host.h"
  67 #include "content/public/browser/render_view_host.h"
  68 #include "content/public/browser/user_metrics.h"
  69 #include "content/public/browser/web_contents.h"
  70 #include "content/public/common/top_controls_state.h"
  71 #include "jni/Tab_jni.h"
  72 #include "net/base/escape.h"
  73 #include "skia/ext/image_operations.h"
  74 #include "third_party/WebKit/public/platform/WebReferrerPolicy.h"
  75 #include "ui/base/resource/resource_bundle.h"
  76 #include "ui/base/window_open_disposition.h"
  77 #include "ui/gfx/android/device_display_info.h"
  78 #include "ui/gfx/android/java_bitmap.h"
  79 #include "ui/gfx/favicon_size.h"
  80 #include "ui/gfx/image/image_skia.h"
  81
  82 using base::android::AttachCurrentThread;
  83 using base::android::ConvertUTF8ToJavaString;
  84 using base::android::ToJavaByteArray;
  85 using content::BrowserThread;
  86 using content::GlobalRequestID;
  87 using content::NavigationController;
  88 using content::WebContents;
  89 using navigation_interception::InterceptNavigationDelegate;
  90 using navigation_interception::NavigationParams;
  91
  92 namespace {
  93
  94 const int kImageSearchThumbnailMinSize = 300 * 300;
  95 const int kImageSearchThumbnailMaxWidth = 600;
  96 const int kImageSearchThumbnailMaxHeight = 600;
  97
  98 }  // namespace
  99
 100 TabAndroid* TabAndroid::FromWebContents(content::WebContents* web_contents) {
 101   CoreTabHelper* core_tab_helper = CoreTabHelper::FromWebContents(web_contents);
 102   if (!core_tab_helper)
 103     return NULL;
 104
 105   CoreTabHelperDelegate* core_delegate = core_tab_helper->delegate();
 106   if (!core_delegate)
 107     return NULL;
 108
 109   return static_cast<TabAndroid*>(core_delegate);
 110 }
 111
 112 TabAndroid* TabAndroid::GetNativeTab(JNIEnv* env, jobject obj) {
 113   return reinterpret_cast<TabAndroid*>(Java_Tab_getNativePtr(env, obj));
 114 }
 115
 116 void TabAndroid::AttachTabHelpers(content::WebContents* web_contents) {
 117   DCHECK(web_contents);
 118
 119   TabHelpers::AttachTabHelpers(web_contents);
 120 }
 121
 122 TabAndroid::TabAndroid(JNIEnv* env, jobject obj)
 123     : weak_java_tab_(env, obj),
 124       content_layer_(cc::Layer::Create()),
 125       tab_content_manager_(NULL),
 126       synced_tab_delegate_(new browser_sync::SyncedTabDelegateAndroid(this)) {
 127   Java_Tab_setNativePtr(env, obj, reinterpret_cast<intptr_t>(this));
 128 }
 129
 130 TabAndroid::~TabAndroid() {
 131   GetContentLayer()->RemoveAllChildren();
 132   JNIEnv* env = base::android::AttachCurrentThread();
 133   Java_Tab_clearNativePtr(env, weak_java_tab_.get(env).obj());
 134 }
 135
 136 base::android::ScopedJavaLocalRef<jobject> TabAndroid::GetJavaObject() {
 137   JNIEnv* env = base::android::AttachCurrentThread();
 138   return weak_java_tab_.get(env);
 139 }
 140
 141 scoped_refptr<cc::Layer> TabAndroid::GetContentLayer() const {
 142   return content_layer_;
 143 }
 144
 145 int TabAndroid::GetAndroidId() const {
 146   JNIEnv* env = base::android::AttachCurrentThread();
 147   return Java_Tab_getId(env, weak_java_tab_.get(env).obj());
 148 }
 149
 150 int TabAndroid::GetSyncId() const {
 151   JNIEnv* env = base::android::AttachCurrentThread();
 152   return Java_Tab_getSyncId(env, weak_java_tab_.get(env).obj());
 153 }
 154
 155 base::string16 TabAndroid::GetTitle() const {
 156   JNIEnv* env = base::android::AttachCurrentThread();
 157   return base::android::ConvertJavaStringToUTF16(
 158       Java_Tab_getTitle(env, weak_java_tab_.get(env).obj()));
 159 }
 160
 161 GURL TabAndroid::GetURL() const {
 162   JNIEnv* env = base::android::AttachCurrentThread();
 163   return GURL(base::android::ConvertJavaStringToUTF8(
 164       Java_Tab_getUrl(env, weak_java_tab_.get(env).obj())));
 165 }
 166
 167 bool TabAndroid::LoadIfNeeded() {
 168   JNIEnv* env = base::android::AttachCurrentThread();
 169   return Java_Tab_loadIfNeeded(env, weak_java_tab_.get(env).obj());
 170 }
 171
 172 content::ContentViewCore* TabAndroid::GetContentViewCore() const {
 173   if (!web_contents())
 174     return NULL;
 175
 176   return content::ContentViewCore::FromWebContents(web_contents());
 177 }
 178
 179 Profile* TabAndroid::GetProfile() const {
 180   if (!web_contents())
 181     return NULL;
 182
 183   return Profile::FromBrowserContext(web_contents()->GetBrowserContext());
 184 }
 185
 186 browser_sync::SyncedTabDelegate* TabAndroid::GetSyncedTabDelegate() const {
 187   return synced_tab_delegate_.get();
 188 }
 189
 190 void TabAndroid::SetWindowSessionID(SessionID::id_type window_id) {
 191   session_window_id_.set_id(window_id);
 192
 193   if (!web_contents())
 194     return;
 195
 196   SessionTabHelper* session_tab_helper =
 197           SessionTabHelper::FromWebContents(web_contents());
 198   session_tab_helper->SetWindowID(session_window_id_);
 199 }
 200
 201 void TabAndroid::SetSyncId(int sync_id) {
 202   JNIEnv* env = base::android::AttachCurrentThread();
 203   Java_Tab_setSyncId(env, weak_java_tab_.get(env).obj(), sync_id);
 204 }
 205
 206 void TabAndroid::HandlePopupNavigation(chrome::NavigateParams* params) {
 207   DCHECK(params->source_contents == web_contents());
 208   DCHECK(params->target_contents == NULL ||
 209          params->target_contents == web_contents());
 210
 211   WindowOpenDisposition disposition = params->disposition;
 212   const GURL& url = params->url;
 213
 214   if (disposition == NEW_POPUP ||
 215       disposition == NEW_FOREGROUND_TAB ||
 216       disposition == NEW_BACKGROUND_TAB ||
 217       disposition == NEW_WINDOW ||
 218       disposition == OFF_THE_RECORD) {
 219     JNIEnv* env = AttachCurrentThread();
 220     ScopedJavaLocalRef<jobject> jobj = weak_java_tab_.get(env);
 221     ScopedJavaLocalRef<jstring> jurl(ConvertUTF8ToJavaString(env, url.spec()));
 222     ScopedJavaLocalRef<jstring> jheaders(
 223         ConvertUTF8ToJavaString(env, params->extra_headers));
 224     ScopedJavaLocalRef<jbyteArray> jpost_data;
 225     if (params->uses_post &&
 226         params->browser_initiated_post_data.get() &&
 227         params->browser_initiated_post_data.get()->size()) {
 228       jpost_data = ToJavaByteArray(
 229           env,
 230           reinterpret_cast<const uint8*>(
 231               params->browser_initiated_post_data.get()->front()),
 232           params->browser_initiated_post_data.get()->size());
 233     }
 234     Java_Tab_openNewTab(env,
 235                         jobj.obj(),
 236                         jurl.obj(),
 237                         jheaders.obj(),
 238                         jpost_data.obj(),
 239                         disposition,
 240                         params->should_set_opener,
 241                         params->is_renderer_initiated);
 242   } else {
 243     NOTIMPLEMENTED();
 244   }
 245 }
 246
 247 bool TabAndroid::HasPrerenderedUrl(GURL gurl) {
 248   prerender::PrerenderManager* prerender_manager = GetPrerenderManager();
 249   if (!prerender_manager)
 250     return false;
 251
 252   std::vector<content::WebContents*> contents =
 253       prerender_manager->GetAllPrerenderingContents();
 254   prerender::PrerenderContents* prerender_contents;
 255   for (size_t i = 0; i < contents.size(); ++i) {
 256     prerender_contents = prerender_manager->
 257         GetPrerenderContents(contents.at(i));
 258     if (prerender_contents->prerender_url() == gurl &&
 259         prerender_contents->has_finished_loading()) {
 260       return true;
 261     }
 262   }
 263   return false;
 264 }
 265
 266 void TabAndroid::MakeLoadURLParams(
 267     chrome::NavigateParams* params,
 268     NavigationController::LoadURLParams* load_url_params) {
 269   load_url_params->referrer = params->referrer;
 270   load_url_params->frame_tree_node_id = params->frame_tree_node_id;
 271   load_url_params->redirect_chain = params->redirect_chain;
 272   load_url_params->transition_type = params->transition;
 273   load_url_params->extra_headers = params->extra_headers;
 274   load_url_params->should_replace_current_entry =
 275       params->should_replace_current_entry;
 276
 277   if (params->transferred_global_request_id != GlobalRequestID()) {
 278     load_url_params->transferred_global_request_id =
 279         params->transferred_global_request_id;
 280   }
 281   load_url_params->is_renderer_initiated = params->is_renderer_initiated;
 282
 283   // Only allows the browser-initiated navigation to use POST.
 284   if (params->uses_post && !params->is_renderer_initiated) {
 285     load_url_params->load_type =
 286         NavigationController::LOAD_TYPE_BROWSER_INITIATED_HTTP_POST;
 287     load_url_params->browser_initiated_post_data =
 288         params->browser_initiated_post_data;
 289   }
 290 }
 291
 292 void TabAndroid::SwapTabContents(content::WebContents* old_contents,
 293                                  content::WebContents* new_contents,
 294                                  bool did_start_load,
 295                                  bool did_finish_load) {
 296   JNIEnv* env = base::android::AttachCurrentThread();
 297   Java_Tab_swapWebContents(
 298       env,
 299       weak_java_tab_.get(env).obj(),
 300       new_contents->GetJavaWebContents().obj(),
 301       did_start_load,
 302       did_finish_load);
 303 }
 304
 305 void TabAndroid::DefaultSearchProviderChanged(
 306     bool google_base_url_domain_changed) {
 307   // TODO(kmadhusu): Move this function definition to a common place and update
 308   // BrowserInstantController::DefaultSearchProviderChanged to use the same.
 309   if (!web_contents())
 310     return;
 311
 312   InstantService* instant_service =
 313       InstantServiceFactory::GetForProfile(GetProfile());
 314   if (!instant_service)
 315     return;
 316
 317   // Send new search URLs to the renderer.
 318   content::RenderProcessHost* rph = web_contents()->GetRenderProcessHost();
 319   instant_service->SendSearchURLsToRenderer(rph);
 320
 321   // Reload the contents to ensure that it gets assigned to a non-previledged
 322   // renderer.
 323   if (!instant_service->IsInstantProcess(rph->GetID()))
 324     return;
 325   web_contents()->GetController().Reload(false);
 326
 327   // As the reload was not triggered by the user we don't want to close any
 328   // infobars. We have to tell the InfoBarService after the reload, otherwise it
 329   // would ignore this call when
 330   // WebContentsObserver::DidStartNavigationToPendingEntry is invoked.
 331   InfoBarService::FromWebContents(web_contents())->set_ignore_next_reload();
 332 }
 333
 334 void TabAndroid::OnWebContentsInstantSupportDisabled(
 335     const content::WebContents* contents) {
 336   DCHECK(contents);
 337   if (web_contents() != contents)
 338     return;
 339
 340   JNIEnv* env = base::android::AttachCurrentThread();
 341   Java_Tab_onWebContentsInstantSupportDisabled(env,
 342                                                weak_java_tab_.get(env).obj());
 343 }
 344
 345 void TabAndroid::Observe(int type,
 346                          const content::NotificationSource& source,
 347                          const content::NotificationDetails& details) {
 348   JNIEnv* env = base::android::AttachCurrentThread();
 349   switch (type) {
 350     case chrome::NOTIFICATION_WEB_CONTENT_SETTINGS_CHANGED: {
 351       TabSpecificContentSettings* settings =
 352           TabSpecificContentSettings::FromWebContents(web_contents());
 353       if (!settings->IsBlockageIndicated(CONTENT_SETTINGS_TYPE_POPUPS)) {
 354         // TODO(dfalcantara): Create an InfoBarDelegate to keep the
 355         // PopupBlockedInfoBar logic native-side instead of straddling the JNI
 356         // boundary.
 357         int num_popups = 0;
 358         PopupBlockerTabHelper* popup_blocker_helper =
 359             PopupBlockerTabHelper::FromWebContents(web_contents());
 360         if (popup_blocker_helper)
 361           num_popups = popup_blocker_helper->GetBlockedPopupsCount();
 362
 363         if (num_popups > 0)
 364           PopupBlockedInfoBarDelegate::Create(web_contents(), num_popups);
 365
 366         settings->SetBlockageHasBeenIndicated(CONTENT_SETTINGS_TYPE_POPUPS);
 367       }
 368       break;
 369     }
 370     case content::NOTIFICATION_NAV_ENTRY_CHANGED:
 371       Java_Tab_onNavEntryChanged(env, weak_java_tab_.get(env).obj());
 372       break;
 373     default:
 374       NOTREACHED() << "Unexpected notification " << type;
 375       break;
 376   }
 377 }
 378
 379 void TabAndroid::OnFaviconAvailable(const gfx::Image& image) {
 380   SkBitmap favicon = image.AsImageSkia().GetRepresentation(1.0f).sk_bitmap();
 381   if (favicon.empty())
 382     return;
 383
 384   JNIEnv *env = base::android::AttachCurrentThread();
 385   Java_Tab_onFaviconAvailable(env, weak_java_tab_.get(env).obj(),
 386                               gfx::ConvertToJavaBitmap(&favicon).obj());
 387 }
 388
 389 void TabAndroid::OnFaviconUpdated(favicon::FaviconDriver* favicon_driver,
 390                                   bool icon_url_changed) {
 391 }
 392
 393 void TabAndroid::Destroy(JNIEnv* env, jobject obj) {
 394   delete this;
 395 }
 396
 397 void TabAndroid::InitWebContents(JNIEnv* env,
 398                                  jobject obj,
 399                                  jboolean incognito,
 400                                  jobject jcontent_view_core,
 401                                  jobject jweb_contents_delegate,
 402                                  jobject jcontext_menu_populator) {
 403   content::ContentViewCore* content_view_core =
 404       content::ContentViewCore::GetNativeContentViewCore(env,
 405                                                          jcontent_view_core);
 406   DCHECK(content_view_core);
 407   DCHECK(content_view_core->GetWebContents());
 408
 409   web_contents_.reset(content_view_core->GetWebContents());
 410   AttachTabHelpers(web_contents_.get());
 411
 412   SetWindowSessionID(session_window_id_.id());
 413
 414   session_tab_id_.set_id(
 415       SessionTabHelper::FromWebContents(web_contents())->session_id().id());
 416   ContextMenuHelper::FromWebContents(web_contents())->SetPopulator(
 417       jcontext_menu_populator);
 418   WindowAndroidHelper::FromWebContents(web_contents())->
 419       SetWindowAndroid(content_view_core->GetWindowAndroid());
 420   CoreTabHelper::FromWebContents(web_contents())->set_delegate(this);
 421   SearchTabHelper::FromWebContents(web_contents())->set_delegate(this);
 422   web_contents_delegate_.reset(
 423       new chrome::android::ChromeWebContentsDelegateAndroid(
 424           env, jweb_contents_delegate));
 425   web_contents_delegate_->LoadProgressChanged(web_contents(), 0);
 426   web_contents()->SetDelegate(web_contents_delegate_.get());
 427
 428   notification_registrar_.Add(
 429       this,
 430       chrome::NOTIFICATION_WEB_CONTENT_SETTINGS_CHANGED,
 431       content::Source<content::WebContents>(web_contents()));
 432   notification_registrar_.Add(
 433       this,
 434       content::NOTIFICATION_NAV_ENTRY_CHANGED,
 435       content::Source<content::NavigationController>(
 436            &web_contents()->GetController()));
 437
 438   favicon::FaviconDriver* favicon_driver =
 439       favicon::ContentFaviconDriver::FromWebContents(web_contents_.get());
 440
 441   if (favicon_driver)
 442     favicon_driver->AddObserver(this);
 443
 444   synced_tab_delegate_->SetWebContents(web_contents());
 445
 446   // Verify that the WebContents this tab represents matches the expected
 447   // off the record state.
 448   CHECK_EQ(GetProfile()->IsOffTheRecord(), incognito);
 449
 450   InstantService* instant_service =
 451       InstantServiceFactory::GetForProfile(GetProfile());
 452   if (instant_service)
 453     instant_service->AddObserver(this);
 454
 455   content_layer_->InsertChild(content_view_core->GetLayer(), 0);
 456 }
 457
 458 void TabAndroid::DestroyWebContents(JNIEnv* env,
 459                                     jobject obj,
 460                                     jboolean delete_native) {
 461   DCHECK(web_contents());
 462
 463   content::ContentViewCore* content_view_core = GetContentViewCore();
 464   if (content_view_core)
 465     content_view_core->GetLayer()->RemoveFromParent();
 466
 467   notification_registrar_.Remove(
 468       this,
 469       chrome::NOTIFICATION_WEB_CONTENT_SETTINGS_CHANGED,
 470       content::Source<content::WebContents>(web_contents()));
 471   notification_registrar_.Remove(
 472       this,
 473       content::NOTIFICATION_NAV_ENTRY_CHANGED,
 474       content::Source<content::NavigationController>(
 475            &web_contents()->GetController()));
 476
 477   favicon::FaviconDriver* favicon_driver =
 478       favicon::ContentFaviconDriver::FromWebContents(web_contents_.get());
 479
 480   if (favicon_driver)
 481     favicon_driver->RemoveObserver(this);
 482
 483   InstantService* instant_service =
 484       InstantServiceFactory::GetForProfile(GetProfile());
 485   if (instant_service)
 486     instant_service->RemoveObserver(this);
 487
 488   web_contents()->SetDelegate(NULL);
 489
 490   if (delete_native) {
 491     // Terminate the renderer process if this is the last tab.
 492     // If there's no unload listener, FastShutdownForPageCount kills the
 493     // renderer process. Otherwise, we go with the slow path where renderer
 494     // process shuts down itself when ref count becomes 0.
 495     // This helps the render process exit quickly which avoids some issues
 496     // during shutdown. See https://codereview.chromium.org/146693011/
 497     // and http://crbug.com/338709 for details.
 498     content::RenderProcessHost* process =
 499         web_contents()->GetRenderProcessHost();
 500     if (process)
 501       process->FastShutdownForPageCount(1);
 502
 503     web_contents_.reset();
 504     synced_tab_delegate_->ResetWebContents();
 505   } else {
 506     // Release the WebContents so it does not get deleted by the scoped_ptr.
 507     ignore_result(web_contents_.release());
 508   }
 509 }
 510
 511 base::android::ScopedJavaLocalRef<jobject> TabAndroid::GetProfileAndroid(
 512     JNIEnv* env,
 513     jobject obj) {
 514   Profile* profile = GetProfile();
 515   if (!profile)
 516     return base::android::ScopedJavaLocalRef<jobject>();
 517   ProfileAndroid* profile_android = ProfileAndroid::FromProfile(profile);
 518   if (!profile_android)
 519     return base::android::ScopedJavaLocalRef<jobject>();
 520
 521   return profile_android->GetJavaObject();
 522 }
 523
 524 TabAndroid::TabLoadStatus TabAndroid::LoadUrl(JNIEnv* env,
 525                                               jobject obj,
 526                                               jstring url,
 527                                               jstring j_extra_headers,
 528                                               jbyteArray j_post_data,
 529                                               jint page_transition,
 530                                               jstring j_referrer_url,
 531                                               jint referrer_policy,
 532                                               jboolean is_renderer_initiated,
 533                                               jlong intent_received_timestamp) {
 534   if (!web_contents())
 535     return PAGE_LOAD_FAILED;
 536
 537   GURL gurl(base::android::ConvertJavaStringToUTF8(env, url));
 538   if (gurl.is_empty())
 539     return PAGE_LOAD_FAILED;
 540
 541   // If the page was prerendered, use it.
 542   // Note in incognito mode, we don't have a PrerenderManager.
 543
 544   prerender::PrerenderManager* prerender_manager =
 545       prerender::PrerenderManagerFactory::GetForProfile(GetProfile());
 546   if (prerender_manager) {
 547     bool prefetched_page_loaded = HasPrerenderedUrl(gurl);
 548     // Getting the load status before MaybeUsePrerenderedPage() b/c it resets.
 549     chrome::NavigateParams params(NULL, web_contents());
 550     InstantSearchPrerenderer* prerenderer =
 551         InstantSearchPrerenderer::GetForProfile(GetProfile());
 552     if (prerenderer) {
 553       const base::string16& search_terms =
 554           chrome::ExtractSearchTermsFromURL(GetProfile(), gurl);
 555       if (!search_terms.empty() &&
 556           prerenderer->CanCommitQuery(web_contents_.get(), search_terms)) {
 557         EmbeddedSearchRequestParams request_params(gurl);
 558         prerenderer->Commit(search_terms, request_params);
 559
 560         if (prerenderer->UsePrerenderedPage(gurl, &params))
 561           return FULL_PRERENDERED_PAGE_LOAD;
 562       }
 563       prerenderer->Cancel();
 564     }
 565     if (prerender_manager->MaybeUsePrerenderedPage(gurl, &params)) {
 566       return prefetched_page_loaded ?
 567           FULL_PRERENDERED_PAGE_LOAD : PARTIAL_PRERENDERED_PAGE_LOAD;
 568     }
 569   }
 570
 571   GURL fixed_url(
 572       url_fixer::FixupURL(gurl.possibly_invalid_spec(), std::string()));
 573   if (!fixed_url.is_valid())
 574     return PAGE_LOAD_FAILED;
 575
 576   if (!HandleNonNavigationAboutURL(fixed_url)) {
 577     // Record UMA "ShowHistory" here. That way it'll pick up both user
 578     // typing chrome://history as well as selecting from the drop down menu.
 579     if (fixed_url.spec() == chrome::kChromeUIHistoryURL) {
 580       content::RecordAction(base::UserMetricsAction("ShowHistory"));
 581     }
 582
 583     content::NavigationController::LoadURLParams load_params(fixed_url);
 584     if (j_extra_headers) {
 585       load_params.extra_headers = base::android::ConvertJavaStringToUTF8(
 586           env,
 587           j_extra_headers);
 588     }
 589     if (j_post_data) {
 590       load_params.load_type =
 591           content::NavigationController::LOAD_TYPE_BROWSER_INITIATED_HTTP_POST;
 592       std::vector<uint8> post_data;
 593       base::android::JavaByteArrayToByteVector(env, j_post_data, &post_data);
 594       load_params.browser_initiated_post_data =
 595           base::RefCountedBytes::TakeVector(&post_data);
 596     }
 597     load_params.transition_type =
 598         ui::PageTransitionFromInt(page_transition);
 599     if (j_referrer_url) {
 600       load_params.referrer = content::Referrer(
 601           GURL(base::android::ConvertJavaStringToUTF8(env, j_referrer_url)),
 602           static_cast<blink::WebReferrerPolicy>(referrer_policy));
 603     }
 604     const base::string16 search_terms =
 605         chrome::ExtractSearchTermsFromURL(GetProfile(), gurl);
 606     SearchTabHelper* search_tab_helper =
 607         SearchTabHelper::FromWebContents(web_contents_.get());
 608     if (!search_terms.empty() && search_tab_helper &&
 609         search_tab_helper->SupportsInstant()) {
 610       EmbeddedSearchRequestParams request_params(gurl);
 611       search_tab_helper->Submit(search_terms, request_params);
 612       return DEFAULT_PAGE_LOAD;
 613     }
 614     load_params.is_renderer_initiated = is_renderer_initiated;
 615     load_params.intent_received_timestamp = intent_received_timestamp;
 616     web_contents()->GetController().LoadURLWithParams(load_params);
 617   }
 618   return DEFAULT_PAGE_LOAD;
 619 }
 620
 621 void TabAndroid::SetActiveNavigationEntryTitleForUrl(JNIEnv* env,
 622                                                      jobject obj,
 623                                                      jstring jurl,
 624                                                      jstring jtitle) {
 625   DCHECK(web_contents());
 626
 627   base::string16 title;
 628   if (jtitle)
 629     title = base::android::ConvertJavaStringToUTF16(env, jtitle);
 630
 631   std::string url;
 632   if (jurl)
 633     url = base::android::ConvertJavaStringToUTF8(env, jurl);
 634
 635   content::NavigationEntry* entry =
 636       web_contents()->GetController().GetVisibleEntry();
 637   if (entry && url == entry->GetVirtualURL().spec())
 638     entry->SetTitle(title);
 639 }
 640
 641 bool TabAndroid::Print(JNIEnv* env, jobject obj) {
 642   if (!web_contents())
 643     return false;
 644
 645   printing::PrintViewManagerBasic::CreateForWebContents(web_contents());
 646   printing::PrintViewManagerBasic* print_view_manager =
 647       printing::PrintViewManagerBasic::FromWebContents(web_contents());
 648   if (print_view_manager == NULL)
 649     return false;
 650
 651   print_view_manager->PrintNow();
 652   return true;
 653 }
 654
 655 void TabAndroid::SetPendingPrint() {
 656   JNIEnv* env = base::android::AttachCurrentThread();
 657   Java_Tab_setPendingPrint(env, weak_java_tab_.get(env).obj());
 658 }
 659
 660 ScopedJavaLocalRef<jobject> TabAndroid::GetFavicon(JNIEnv* env,
 661                                                    jobject obj) {
 662
 663   ScopedJavaLocalRef<jobject> bitmap;
 664   favicon::FaviconDriver* favicon_driver =
 665       favicon::ContentFaviconDriver::FromWebContents(web_contents_.get());
 666
 667   if (!favicon_driver)
 668     return bitmap;
 669
 670   // Always return the default favicon in Android.
 671   SkBitmap favicon = favicon_driver->GetFavicon().AsBitmap();
 672   if (!favicon.empty()) {
 673     gfx::DeviceDisplayInfo device_info;
 674     const float device_scale_factor = device_info.GetDIPScale();
 675     int target_size_dip = device_scale_factor * gfx::kFaviconSize;
 676     if (favicon.width() != target_size_dip ||
 677         favicon.height() != target_size_dip) {
 678       favicon =
 679           skia::ImageOperations::Resize(favicon,
 680                                         skia::ImageOperations::RESIZE_BEST,
 681                                         target_size_dip,
 682                                         target_size_dip);
 683     }
 684
 685     bitmap = gfx::ConvertToJavaBitmap(&favicon);
 686   }
 687   return bitmap;
 688 }
 689
 690 prerender::PrerenderManager* TabAndroid::GetPrerenderManager() const {
 691   Profile* profile = GetProfile();
 692   if (!profile)
 693     return NULL;
 694   return prerender::PrerenderManagerFactory::GetForProfile(profile);
 695 }
 696
 697 // static
 698 void TabAndroid::CreateHistoricalTabFromContents(WebContents* web_contents) {
 699   DCHECK(web_contents);
 700
 701   TabRestoreService* service =
 702       TabRestoreServiceFactory::GetForProfile(
 703           Profile::FromBrowserContext(web_contents->GetBrowserContext()));
 704   if (!service)
 705     return;
 706
 707   // Exclude internal pages from being marked as recent when they are closed.
 708   const GURL& tab_url = web_contents->GetURL();
 709   if (tab_url.SchemeIs(content::kChromeUIScheme) ||
 710       tab_url.SchemeIs(chrome::kChromeNativeScheme) ||
 711       tab_url.SchemeIs(url::kAboutScheme)) {
 712     return;
 713   }
 714
 715   // TODO(jcivelli): is the index important?
 716   service->CreateHistoricalTab(web_contents, -1);
 717 }
 718
 719 void TabAndroid::CreateHistoricalTab(JNIEnv* env, jobject obj) {
 720   TabAndroid::CreateHistoricalTabFromContents(web_contents());
 721 }
 722
 723 void TabAndroid::UpdateTopControlsState(JNIEnv* env,
 724                                         jobject obj,
 725                                         jint constraints,
 726                                         jint current,
 727                                         jboolean animate) {
 728   content::TopControlsState constraints_state =
 729       static_cast<content::TopControlsState>(constraints);
 730   content::TopControlsState current_state =
 731       static_cast<content::TopControlsState>(current);
 732   WebContents* sender = web_contents();
 733   sender->Send(new ChromeViewMsg_UpdateTopControlsState(
 734       sender->GetRoutingID(), constraints_state, current_state, animate));
 735
 736   if (sender->ShowingInterstitialPage()) {
 737     content::RenderViewHost* interstitial_view_host =
 738         sender->GetInterstitialPage()->GetMainFrame()->GetRenderViewHost();
 739     interstitial_view_host->Send(new ChromeViewMsg_UpdateTopControlsState(
 740         interstitial_view_host->GetRoutingID(), constraints_state,
 741         current_state, animate));
 742   }
 743 }
 744
 745 void TabAndroid::SearchByImageInNewTabAsync(JNIEnv* env, jobject obj) {
 746   content::RenderFrameHost* render_frame_host =
 747         web_contents()->GetMainFrame();
 748   render_frame_host->Send(
 749       new ChromeViewMsg_RequestThumbnailForContextNode(
 750           render_frame_host->GetRoutingID(),
 751           kImageSearchThumbnailMinSize,
 752           gfx::Size(kImageSearchThumbnailMaxWidth,
 753                     kImageSearchThumbnailMaxHeight)));
 754 }
 755
 756 jlong TabAndroid::GetBookmarkId(JNIEnv* env,
 757                                jobject obj,
 758                                jboolean only_editable) {
 759   const GURL& url = dom_distiller::url_utils::GetOriginalUrlFromDistillerUrl(
 760       web_contents()->GetURL());
 761   Profile* profile = GetProfile();
 762
 763   // Get all the nodes for |url| and sort them by date added.
 764   std::vector<const bookmarks::BookmarkNode*> nodes;
 765   ChromeBookmarkClient* client =
 766       ChromeBookmarkClientFactory::GetForProfile(profile);
 767   bookmarks::BookmarkModel* model =
 768       BookmarkModelFactory::GetForProfile(profile);
 769   model->GetNodesByURL(url, &nodes);
 770   std::sort(nodes.begin(), nodes.end(), &bookmarks::MoreRecentlyAdded);
 771
 772   // Return the first node matching the search criteria.
 773   for (size_t i = 0; i < nodes.size(); ++i) {
 774     if (only_editable && !client->CanBeEditedByUser(nodes[i]))
 775       continue;
 776     return nodes[i]->id();
 777   }
 778
 779   return -1;
 780 }
 781
 782 bool TabAndroid::HasPrerenderedUrl(JNIEnv* env, jobject obj, jstring url) {
 783   GURL gurl(base::android::ConvertJavaStringToUTF8(env, url));
 784   return HasPrerenderedUrl(gurl);
 785 }
 786
 787 namespace {
 788
 789 class ChromeInterceptNavigationDelegate : public InterceptNavigationDelegate {
 790  public:
 791   ChromeInterceptNavigationDelegate(JNIEnv* env, jobject jdelegate)
 792       : InterceptNavigationDelegate(env, jdelegate) {}
 793
 794   bool ShouldIgnoreNavigation(
 795       const NavigationParams& navigation_params) override {
 796     NavigationParams chrome_navigation_params(navigation_params);
 797     chrome_navigation_params.url() =
 798         GURL(net::EscapeExternalHandlerValue(navigation_params.url().spec()));
 799     return InterceptNavigationDelegate::ShouldIgnoreNavigation(
 800         chrome_navigation_params);
 801   }
 802 };
 803
 804 }  // namespace
 805
 806 void TabAndroid::SetInterceptNavigationDelegate(JNIEnv* env, jobject obj,
 807                                                jobject delegate) {
 808   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 809   InterceptNavigationDelegate::Associate(
 810       web_contents(),
 811       make_scoped_ptr(new ChromeInterceptNavigationDelegate(env, delegate)));
 812 }
 813
 814 void TabAndroid::AttachToTabContentManager(JNIEnv* env,
 815                                            jobject obj,
 816                                            jobject jtab_content_manager) {
 817   chrome::android::TabContentManager* tab_content_manager =
 818       chrome::android::TabContentManager::FromJavaObject(jtab_content_manager);
 819   if (tab_content_manager == tab_content_manager_)
 820     return;
 821
 822   if (tab_content_manager_)
 823     tab_content_manager_->DetachLiveLayer(GetAndroidId(), GetContentLayer());
 824   tab_content_manager_ = tab_content_manager;
 825   if (tab_content_manager_)
 826     tab_content_manager_->AttachLiveLayer(GetAndroidId(), GetContentLayer());
 827 }
 828
 829 void TabAndroid::AttachOverlayContentViewCore(JNIEnv* env,
 830                                               jobject obj,
 831                                               jobject jcontent_view_core,
 832                                               jboolean visible) {
 833   content::ContentViewCore* content_view_core =
 834       content::ContentViewCore::GetNativeContentViewCore(env,
 835                                                          jcontent_view_core);
 836   DCHECK(content_view_core);
 837
 838   content_view_core->GetLayer()->SetHideLayerAndSubtree(!visible);
 839   content_layer_->AddChild(content_view_core->GetLayer());
 840 }
 841
 842 void TabAndroid::DetachOverlayContentViewCore(JNIEnv* env,
 843                                               jobject obj,
 844                                               jobject jcontent_view_core) {
 845   content::ContentViewCore* content_view_core =
 846       content::ContentViewCore::GetNativeContentViewCore(env,
 847                                                          jcontent_view_core);
 848   DCHECK(content_view_core);
 849
 850   if (content_view_core->GetLayer()->parent() == content_layer_)
 851     content_view_core->GetLayer()->RemoveFromParent();
 852 }
 853
 854 static void Init(JNIEnv* env, jobject obj) {
 855   TRACE_EVENT0("native", "TabAndroid::Init");
 856   // This will automatically bind to the Java object and pass ownership there.
 857   new TabAndroid(env, obj);
 858 }
 859
 860 // static
 861 bool TabAndroid::RegisterTabAndroid(JNIEnv* env) {
 862   return RegisterNativesImpl(env);
 863 }
 864
 865 static void RecordStartupToCommitUma(JNIEnv* env, jclass jcaller) {
 866   // Currently it takes about 2000ms to commit a navigation if the measurement
 867   // begins very early in the browser start. How many buckets (b) are needed to
 868   // explore the _typical_ values with granularity 100ms and a maximum duration
 869   // of 1 minute?
 870   //   s^{n+1} / s^{n} = 2100 / 2000
 871   //   s = 1.05
 872   //   s^b = 60000
 873   //   b = ln(60000) / ln(1.05) ~= 225
 874   UMA_HISTOGRAM_CUSTOM_TIMES("Startup.FirstCommitNavigationTime",
 875       base::Time::Now() - chrome::android::GetMainEntryPointTime(),
 876       base::TimeDelta::FromMilliseconds(1),
 877       base::TimeDelta::FromMinutes(1),
 878       225);
 879 }