android_webview/native/aw_contents.cc

   1 // Copyright 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 "android_webview/native/aw_contents.h"
   6
   7 #include <limits>
   8
   9 #include "android_webview/browser/aw_browser_context.h"
  10 #include "android_webview/browser/aw_browser_main_parts.h"
  11 #include "android_webview/browser/aw_resource_context.h"
  12 #include "android_webview/browser/browser_view_renderer.h"
  13 #include "android_webview/browser/gpu_memory_buffer_factory_impl.h"
  14 #include "android_webview/browser/hardware_renderer.h"
  15 #include "android_webview/browser/net_disk_cache_remover.h"
  16 #include "android_webview/browser/renderer_host/aw_resource_dispatcher_host_delegate.h"
  17 #include "android_webview/common/aw_hit_test_data.h"
  18 #include "android_webview/common/devtools_instrumentation.h"
  19 #include "android_webview/native/aw_autofill_manager_delegate.h"
  20 #include "android_webview/native/aw_browser_dependency_factory.h"
  21 #include "android_webview/native/aw_contents_client_bridge.h"
  22 #include "android_webview/native/aw_contents_io_thread_client_impl.h"
  23 #include "android_webview/native/aw_pdf_exporter.h"
  24 #include "android_webview/native/aw_picture.h"
  25 #include "android_webview/native/aw_web_contents_delegate.h"
  26 #include "android_webview/native/java_browser_view_renderer_helper.h"
  27 #include "android_webview/native/state_serializer.h"
  28 #include "android_webview/public/browser/draw_gl.h"
  29 #include "base/android/jni_android.h"
  30 #include "base/android/jni_array.h"
  31 #include "base/android/jni_string.h"
  32 #include "base/android/scoped_java_ref.h"
  33 #include "base/atomicops.h"
  34 #include "base/bind.h"
  35 #include "base/callback.h"
  36 #include "base/memory/memory_pressure_listener.h"
  37 #include "base/message_loop/message_loop.h"
  38 #include "base/pickle.h"
  39 #include "base/strings/string16.h"
  40 #include "base/supports_user_data.h"
  41 #include "components/autofill/content/browser/content_autofill_driver.h"
  42 #include "components/autofill/core/browser/autofill_manager.h"
  43 #include "components/autofill/core/browser/webdata/autofill_webdata_service.h"
  44 #include "components/navigation_interception/intercept_navigation_delegate.h"
  45 #include "content/public/browser/android/content_view_core.h"
  46 #include "content/public/browser/browser_thread.h"
  47 #include "content/public/browser/cert_store.h"
  48 #include "content/public/browser/favicon_status.h"
  49 #include "content/public/browser/navigation_entry.h"
  50 #include "content/public/browser/render_frame_host.h"
  51 #include "content/public/browser/render_process_host.h"
  52 #include "content/public/browser/render_view_host.h"
  53 #include "content/public/browser/web_contents.h"
  54 #include "content/public/common/renderer_preferences.h"
  55 #include "content/public/common/ssl_status.h"
  56 #include "jni/AwContents_jni.h"
  57 #include "net/cert/x509_certificate.h"
  58 #include "third_party/skia/include/core/SkPicture.h"
  59 #include "ui/base/l10n/l10n_util_android.h"
  60 #include "ui/gfx/android/java_bitmap.h"
  61 #include "ui/gfx/font_render_params_linux.h"
  62 #include "ui/gfx/image/image.h"
  63 #include "ui/gfx/size.h"
  64
  65 struct AwDrawSWFunctionTable;
  66 struct AwDrawGLFunctionTable;
  67
  68 using autofill::ContentAutofillDriver;
  69 using autofill::AutofillManager;
  70 using base::android::AttachCurrentThread;
  71 using base::android::ConvertJavaStringToUTF16;
  72 using base::android::ConvertJavaStringToUTF8;
  73 using base::android::ConvertUTF16ToJavaString;
  74 using base::android::ConvertUTF8ToJavaString;
  75 using base::android::JavaRef;
  76 using base::android::ScopedJavaGlobalRef;
  77 using base::android::ScopedJavaLocalRef;
  78 using navigation_interception::InterceptNavigationDelegate;
  79 using content::BrowserThread;
  80 using content::ContentViewCore;
  81 using content::WebContents;
  82
  83 extern "C" {
  84 static AwDrawGLFunction DrawGLFunction;
  85 static void DrawGLFunction(int view_context,
  86                            AwDrawGLInfo* draw_info,
  87                            void* spare) {
  88   // |view_context| is the value that was returned from the java
  89   // AwContents.onPrepareDrawGL; this cast must match the code there.
  90   reinterpret_cast<android_webview::AwContents*>(view_context)
  91       ->DrawGL(draw_info);
  92 }
  93 }
  94
  95 namespace android_webview {
  96
  97 namespace {
  98
  99 bool g_should_download_favicons = false;
 100
 101 const void* kAwContentsUserDataKey = &kAwContentsUserDataKey;
 102
 103 class AwContentsUserData : public base::SupportsUserData::Data {
 104  public:
 105   AwContentsUserData(AwContents* ptr) : contents_(ptr) {}
 106
 107   static AwContents* GetContents(WebContents* web_contents) {
 108     if (!web_contents)
 109       return NULL;
 110     AwContentsUserData* data = reinterpret_cast<AwContentsUserData*>(
 111         web_contents->GetUserData(kAwContentsUserDataKey));
 112     return data ? data->contents_ : NULL;
 113   }
 114
 115  private:
 116   AwContents* contents_;
 117 };
 118
 119 base::subtle::Atomic32 g_instance_count = 0;
 120
 121 // TODO(boliu): Deduplicate with chrome/ code.
 122 content::RendererPreferencesHintingEnum GetRendererPreferencesHintingEnum(
 123     gfx::FontRenderParams::Hinting hinting) {
 124   switch (hinting) {
 125     case gfx::FontRenderParams::HINTING_NONE:
 126       return content::RENDERER_PREFERENCES_HINTING_NONE;
 127     case gfx::FontRenderParams::HINTING_SLIGHT:
 128       return content::RENDERER_PREFERENCES_HINTING_SLIGHT;
 129     case gfx::FontRenderParams::HINTING_MEDIUM:
 130       return content::RENDERER_PREFERENCES_HINTING_MEDIUM;
 131     case gfx::FontRenderParams::HINTING_FULL:
 132       return content::RENDERER_PREFERENCES_HINTING_FULL;
 133     default:
 134       NOTREACHED() << "Unhandled hinting style " << hinting;
 135       return content::RENDERER_PREFERENCES_HINTING_SYSTEM_DEFAULT;
 136   }
 137 }
 138
 139 // TODO(boliu): Deduplicate with chrome/ code.
 140 content::RendererPreferencesSubpixelRenderingEnum
 141 GetRendererPreferencesSubpixelRenderingEnum(
 142     gfx::FontRenderParams::SubpixelRendering subpixel_rendering) {
 143   switch (subpixel_rendering) {
 144     case gfx::FontRenderParams::SUBPIXEL_RENDERING_NONE:
 145       return content::RENDERER_PREFERENCES_SUBPIXEL_RENDERING_NONE;
 146     case gfx::FontRenderParams::SUBPIXEL_RENDERING_RGB:
 147       return content::RENDERER_PREFERENCES_SUBPIXEL_RENDERING_RGB;
 148     case gfx::FontRenderParams::SUBPIXEL_RENDERING_BGR:
 149       return content::RENDERER_PREFERENCES_SUBPIXEL_RENDERING_BGR;
 150     case gfx::FontRenderParams::SUBPIXEL_RENDERING_VRGB:
 151       return content::RENDERER_PREFERENCES_SUBPIXEL_RENDERING_VRGB;
 152     case gfx::FontRenderParams::SUBPIXEL_RENDERING_VBGR:
 153       return content::RENDERER_PREFERENCES_SUBPIXEL_RENDERING_VBGR;
 154     default:
 155       NOTREACHED() << "Unhandled subpixel rendering style "
 156                    << subpixel_rendering;
 157       return content::RENDERER_PREFERENCES_SUBPIXEL_RENDERING_SYSTEM_DEFAULT;
 158   }
 159 }
 160
 161 void OnIoThreadClientReady(content::RenderFrameHost* rfh) {
 162   int render_process_id = rfh->GetProcess()->GetID();
 163   int render_frame_id = rfh->GetRoutingID();
 164   AwResourceDispatcherHostDelegate::OnIoThreadClientReady(
 165       render_process_id, render_frame_id);
 166 }
 167
 168 }  // namespace
 169
 170 // static
 171 AwContents* AwContents::FromWebContents(WebContents* web_contents) {
 172   return AwContentsUserData::GetContents(web_contents);
 173 }
 174
 175 // static
 176 AwContents* AwContents::FromID(int render_process_id, int render_view_id) {
 177   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 178   const content::RenderViewHost* rvh =
 179       content::RenderViewHost::FromID(render_process_id, render_view_id);
 180   if (!rvh) return NULL;
 181   content::WebContents* web_contents =
 182       content::WebContents::FromRenderViewHost(rvh);
 183   if (!web_contents) return NULL;
 184   return FromWebContents(web_contents);
 185 }
 186
 187 AwContents::AwContents(scoped_ptr<WebContents> web_contents)
 188     : weak_factory_on_ui_thread_(this),
 189       ui_thread_weak_ptr_(weak_factory_on_ui_thread_.GetWeakPtr()),
 190       web_contents_(web_contents.Pass()),
 191       shared_renderer_state_(
 192           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
 193           this),
 194       browser_view_renderer_(
 195           this,
 196           &shared_renderer_state_,
 197           web_contents_.get(),
 198           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI)) {
 199   base::subtle::NoBarrier_AtomicIncrement(&g_instance_count, 1);
 200   icon_helper_.reset(new IconHelper(web_contents_.get()));
 201   icon_helper_->SetListener(this);
 202   web_contents_->SetUserData(kAwContentsUserDataKey,
 203                              new AwContentsUserData(this));
 204   render_view_host_ext_.reset(
 205       new AwRenderViewHostExt(this, web_contents_.get()));
 206
 207   AwAutofillManagerDelegate* autofill_manager_delegate =
 208       AwAutofillManagerDelegate::FromWebContents(web_contents_.get());
 209   if (autofill_manager_delegate)
 210     InitAutofillIfNecessary(autofill_manager_delegate->GetSaveFormData());
 211
 212   SetAndroidWebViewRendererPrefs();
 213 }
 214
 215 void AwContents::SetJavaPeers(JNIEnv* env,
 216                               jobject obj,
 217                               jobject aw_contents,
 218                               jobject web_contents_delegate,
 219                               jobject contents_client_bridge,
 220                               jobject io_thread_client,
 221                               jobject intercept_navigation_delegate) {
 222   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 223   // The |aw_content| param is technically spurious as it duplicates |obj| but
 224   // is passed over anyway to make the binding more explicit.
 225   java_ref_ = JavaObjectWeakGlobalRef(env, aw_contents);
 226
 227   web_contents_delegate_.reset(
 228       new AwWebContentsDelegate(env, web_contents_delegate));
 229   web_contents_->SetDelegate(web_contents_delegate_.get());
 230
 231   contents_client_bridge_.reset(
 232       new AwContentsClientBridge(env, contents_client_bridge));
 233   AwContentsClientBridgeBase::Associate(web_contents_.get(),
 234                                         contents_client_bridge_.get());
 235
 236   AwContentsIoThreadClientImpl::Associate(
 237       web_contents_.get(), ScopedJavaLocalRef<jobject>(env, io_thread_client));
 238
 239   InterceptNavigationDelegate::Associate(
 240       web_contents_.get(),
 241       make_scoped_ptr(new InterceptNavigationDelegate(
 242           env, intercept_navigation_delegate)));
 243
 244   // Finally, having setup the associations, release any deferred requests
 245   web_contents_->ForEachFrame(base::Bind(&OnIoThreadClientReady));
 246 }
 247
 248 void AwContents::SetSaveFormData(bool enabled) {
 249   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 250   InitAutofillIfNecessary(enabled);
 251   // We need to check for the existence, since autofill_manager_delegate
 252   // may not be created when the setting is false.
 253   if (ContentAutofillDriver::FromWebContents(web_contents_.get())) {
 254     AwAutofillManagerDelegate::FromWebContents(web_contents_.get())->
 255         SetSaveFormData(enabled);
 256   }
 257 }
 258
 259 void AwContents::InitAutofillIfNecessary(bool enabled) {
 260   // Do not initialize if the feature is not enabled.
 261   if (!enabled)
 262     return;
 263   // Check if the autofill driver already exists.
 264   content::WebContents* web_contents = web_contents_.get();
 265   if (ContentAutofillDriver::FromWebContents(web_contents))
 266     return;
 267
 268   AwBrowserContext::FromWebContents(web_contents)->
 269       CreateUserPrefServiceIfNecessary();
 270   AwAutofillManagerDelegate::CreateForWebContents(web_contents);
 271   ContentAutofillDriver::CreateForWebContentsAndDelegate(
 272       web_contents,
 273       AwAutofillManagerDelegate::FromWebContents(web_contents),
 274       l10n_util::GetDefaultLocale(),
 275       AutofillManager::DISABLE_AUTOFILL_DOWNLOAD_MANAGER);
 276 }
 277
 278 void AwContents::SetAndroidWebViewRendererPrefs() {
 279   content::RendererPreferences* prefs =
 280       web_contents_->GetMutableRendererPrefs();
 281   prefs->tap_multiple_targets_strategy =
 282       content::TAP_MULTIPLE_TARGETS_STRATEGY_NONE;
 283
 284   // TODO(boliu): Deduplicate with chrome/ code.
 285   const gfx::FontRenderParams& params = gfx::GetDefaultWebKitFontRenderParams();
 286   prefs->should_antialias_text = params.antialiasing;
 287   prefs->use_subpixel_positioning = params.subpixel_positioning;
 288   prefs->hinting = GetRendererPreferencesHintingEnum(params.hinting);
 289   prefs->use_autohinter = params.autohinter;
 290   prefs->use_bitmaps = params.use_bitmaps;
 291   prefs->subpixel_rendering =
 292       GetRendererPreferencesSubpixelRenderingEnum(params.subpixel_rendering);
 293
 294   content::RenderViewHost* host = web_contents_->GetRenderViewHost();
 295   if (host)
 296     host->SyncRendererPrefs();
 297 }
 298
 299 void AwContents::SetAwAutofillManagerDelegate(jobject delegate) {
 300   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 301   JNIEnv* env = AttachCurrentThread();
 302   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
 303   if (obj.is_null())
 304     return;
 305   Java_AwContents_setAwAutofillManagerDelegate(env, obj.obj(), delegate);
 306 }
 307
 308 AwContents::~AwContents() {
 309   DCHECK(AwContents::FromWebContents(web_contents_.get()) == this);
 310   DCHECK(!hardware_renderer_.get());
 311   web_contents_->RemoveUserData(kAwContentsUserDataKey);
 312   if (find_helper_.get())
 313     find_helper_->SetListener(NULL);
 314   if (icon_helper_.get())
 315     icon_helper_->SetListener(NULL);
 316   base::subtle::NoBarrier_AtomicIncrement(&g_instance_count, -1);
 317   // When the last WebView is destroyed free all discardable memory allocated by
 318   // Chromium, because the app process may continue to run for a long time
 319   // without ever using another WebView.
 320   if (base::subtle::NoBarrier_Load(&g_instance_count) == 0) {
 321     base::MemoryPressureListener::NotifyMemoryPressure(
 322         base::MemoryPressureListener::MEMORY_PRESSURE_CRITICAL);
 323   }
 324 }
 325
 326 jint AwContents::GetWebContents(JNIEnv* env, jobject obj) {
 327   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 328   DCHECK(web_contents_);
 329   return reinterpret_cast<jint>(web_contents_.get());
 330 }
 331
 332 void AwContents::Destroy(JNIEnv* env, jobject obj) {
 333   java_ref_.reset();
 334   // We do not delete AwContents immediately. Some applications try to delete
 335   // Webview in ShouldOverrideUrlLoading callback, which is a sync IPC from
 336   // Webkit.
 337   BrowserThread::DeleteSoon(BrowserThread::UI, FROM_HERE, this);
 338 }
 339
 340 static jlong Init(JNIEnv* env, jclass, jobject browser_context) {
 341   // TODO(joth): Use |browser_context| to get the native BrowserContext, rather
 342   // than hard-code the default instance lookup here.
 343   scoped_ptr<WebContents> web_contents(content::WebContents::Create(
 344       content::WebContents::CreateParams(AwBrowserContext::GetDefault())));
 345   // Return an 'uninitialized' instance; most work is deferred until the
 346   // subsequent SetJavaPeers() call.
 347   return reinterpret_cast<intptr_t>(new AwContents(web_contents.Pass()));
 348 }
 349
 350 static void SetAwDrawSWFunctionTable(JNIEnv* env, jclass, jint function_table) {
 351   JavaBrowserViewRendererHelper::SetAwDrawSWFunctionTable(
 352       reinterpret_cast<AwDrawSWFunctionTable*>(function_table));
 353 }
 354
 355 static void SetAwDrawGLFunctionTable(JNIEnv* env, jclass, jint function_table) {
 356   GpuMemoryBufferFactoryImpl::SetAwDrawGLFunctionTable(
 357       reinterpret_cast<AwDrawGLFunctionTable*>(function_table));
 358 }
 359
 360 static jint GetAwDrawGLFunction(JNIEnv* env, jclass) {
 361   return reinterpret_cast<jint>(&DrawGLFunction);
 362 }
 363
 364 // static
 365 jint GetNativeInstanceCount(JNIEnv* env, jclass) {
 366   return base::subtle::NoBarrier_Load(&g_instance_count);
 367 }
 368
 369 jint AwContents::GetAwDrawGLViewContext(JNIEnv* env, jobject obj) {
 370   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 371   return reinterpret_cast<jint>(this);
 372 }
 373
 374 void AwContents::DrawGL(AwDrawGLInfo* draw_info) {
 375   if (!hardware_renderer_) {
 376     // TODO(boliu): Use executeHardwareAction to synchronously initialize
 377     // hardware on first functor request. Then functor can point directly
 378     // to HardwareRenderer.
 379     hardware_renderer_.reset(new HardwareRenderer(&shared_renderer_state_));
 380   }
 381
 382   DrawGLResult result;
 383   if (hardware_renderer_->DrawGL(draw_info, &result)) {
 384     content::BrowserThread::PostTask(
 385         content::BrowserThread::UI,
 386         FROM_HERE,
 387         base::Bind(&AwContents::DidDrawGL, ui_thread_weak_ptr_, result));
 388   }
 389 }
 390
 391 void AwContents::DidDrawGL(const DrawGLResult& result) {
 392   browser_view_renderer_.DidDrawGL(result);
 393 }
 394
 395 namespace {
 396 void DocumentHasImagesCallback(const ScopedJavaGlobalRef<jobject>& message,
 397                                bool has_images) {
 398   Java_AwContents_onDocumentHasImagesResponse(AttachCurrentThread(),
 399                                               has_images,
 400                                               message.obj());
 401 }
 402 }  // namespace
 403
 404 void AwContents::DocumentHasImages(JNIEnv* env, jobject obj, jobject message) {
 405   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 406   ScopedJavaGlobalRef<jobject> j_message;
 407   j_message.Reset(env, message);
 408   render_view_host_ext_->DocumentHasImages(
 409       base::Bind(&DocumentHasImagesCallback, j_message));
 410 }
 411
 412 namespace {
 413 void GenerateMHTMLCallback(ScopedJavaGlobalRef<jobject>* callback,
 414                            const base::FilePath& path, int64 size) {
 415   JNIEnv* env = AttachCurrentThread();
 416   // Android files are UTF8, so the path conversion below is safe.
 417   Java_AwContents_generateMHTMLCallback(
 418       env,
 419       ConvertUTF8ToJavaString(env, path.AsUTF8Unsafe()).obj(),
 420       size, callback->obj());
 421 }
 422 }  // namespace
 423
 424 void AwContents::GenerateMHTML(JNIEnv* env, jobject obj,
 425                                jstring jpath, jobject callback) {
 426   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 427   ScopedJavaGlobalRef<jobject>* j_callback = new ScopedJavaGlobalRef<jobject>();
 428   j_callback->Reset(env, callback);
 429   base::FilePath target_path(ConvertJavaStringToUTF8(env, jpath));
 430   web_contents_->GenerateMHTML(
 431       target_path,
 432       base::Bind(&GenerateMHTMLCallback, base::Owned(j_callback), target_path));
 433 }
 434
 435 void AwContents::CreatePdfExporter(JNIEnv* env,
 436                                    jobject obj,
 437                                    jobject pdfExporter) {
 438   pdf_exporter_.reset(
 439       new AwPdfExporter(env,
 440                         pdfExporter,
 441                         web_contents_.get()));
 442 }
 443
 444 bool AwContents::OnReceivedHttpAuthRequest(const JavaRef<jobject>& handler,
 445                                            const std::string& host,
 446                                            const std::string& realm) {
 447   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 448   JNIEnv* env = AttachCurrentThread();
 449   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
 450   if (obj.is_null())
 451     return false;
 452
 453   ScopedJavaLocalRef<jstring> jhost = ConvertUTF8ToJavaString(env, host);
 454   ScopedJavaLocalRef<jstring> jrealm = ConvertUTF8ToJavaString(env, realm);
 455   devtools_instrumentation::ScopedEmbedderCallbackTask embedder_callback(
 456       "onReceivedHttpAuthRequest");
 457   Java_AwContents_onReceivedHttpAuthRequest(env, obj.obj(), handler.obj(),
 458       jhost.obj(), jrealm.obj());
 459   return true;
 460 }
 461
 462 void AwContents::AddVisitedLinks(JNIEnv* env,
 463                                    jobject obj,
 464                                    jobjectArray jvisited_links) {
 465   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 466   std::vector<base::string16> visited_link_strings;
 467   base::android::AppendJavaStringArrayToStringVector(
 468       env, jvisited_links, &visited_link_strings);
 469
 470   std::vector<GURL> visited_link_gurls;
 471   std::vector<base::string16>::const_iterator itr;
 472   for (itr = visited_link_strings.begin(); itr != visited_link_strings.end();
 473        ++itr) {
 474     visited_link_gurls.push_back(GURL(*itr));
 475   }
 476
 477   AwBrowserContext::FromWebContents(web_contents_.get())
 478       ->AddVisitedURLs(visited_link_gurls);
 479 }
 480
 481 bool RegisterAwContents(JNIEnv* env) {
 482   return RegisterNativesImpl(env) >= 0;
 483 }
 484
 485 namespace {
 486
 487 void ShowGeolocationPromptHelperTask(const JavaObjectWeakGlobalRef& java_ref,
 488                                      const GURL& origin) {
 489   JNIEnv* env = AttachCurrentThread();
 490   ScopedJavaLocalRef<jobject> j_ref = java_ref.get(env);
 491   if (j_ref.obj()) {
 492     ScopedJavaLocalRef<jstring> j_origin(
 493         ConvertUTF8ToJavaString(env, origin.spec()));
 494     devtools_instrumentation::ScopedEmbedderCallbackTask embedder_callback(
 495         "onGeolocationPermissionsShowPrompt");
 496     Java_AwContents_onGeolocationPermissionsShowPrompt(env,
 497                                                        j_ref.obj(),
 498                                                        j_origin.obj());
 499   }
 500 }
 501
 502 void ShowGeolocationPromptHelper(const JavaObjectWeakGlobalRef& java_ref,
 503                                  const GURL& origin) {
 504   JNIEnv* env = AttachCurrentThread();
 505   if (java_ref.get(env).obj()) {
 506     content::BrowserThread::PostTask(
 507         content::BrowserThread::UI,
 508         FROM_HERE,
 509         base::Bind(&ShowGeolocationPromptHelperTask,
 510                    java_ref,
 511                    origin));
 512   }
 513 }
 514
 515 } // anonymous namespace
 516
 517 void AwContents::ShowGeolocationPrompt(const GURL& requesting_frame,
 518                                        base::Callback<void(bool)> callback) {
 519   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 520
 521   GURL origin = requesting_frame.GetOrigin();
 522   bool show_prompt = pending_geolocation_prompts_.empty();
 523   pending_geolocation_prompts_.push_back(OriginCallback(origin, callback));
 524   if (show_prompt) {
 525     ShowGeolocationPromptHelper(java_ref_, origin);
 526   }
 527 }
 528
 529 // Invoked from Java
 530 void AwContents::InvokeGeolocationCallback(JNIEnv* env,
 531                                            jobject obj,
 532                                            jboolean value,
 533                                            jstring origin) {
 534   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 535
 536   GURL callback_origin(base::android::ConvertJavaStringToUTF16(env, origin));
 537   if (callback_origin.GetOrigin() ==
 538       pending_geolocation_prompts_.front().first) {
 539     pending_geolocation_prompts_.front().second.Run(value);
 540     pending_geolocation_prompts_.pop_front();
 541     if (!pending_geolocation_prompts_.empty()) {
 542       ShowGeolocationPromptHelper(java_ref_,
 543                                   pending_geolocation_prompts_.front().first);
 544     }
 545   }
 546 }
 547
 548 void AwContents::HideGeolocationPrompt(const GURL& origin) {
 549   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 550   bool removed_current_outstanding_callback = false;
 551   std::list<OriginCallback>::iterator it = pending_geolocation_prompts_.begin();
 552   while (it != pending_geolocation_prompts_.end()) {
 553     if ((*it).first == origin.GetOrigin()) {
 554       if (it == pending_geolocation_prompts_.begin()) {
 555         removed_current_outstanding_callback = true;
 556       }
 557       it = pending_geolocation_prompts_.erase(it);
 558     } else {
 559       ++it;
 560     }
 561   }
 562
 563   if (removed_current_outstanding_callback) {
 564     JNIEnv* env = AttachCurrentThread();
 565     ScopedJavaLocalRef<jobject> j_ref = java_ref_.get(env);
 566     if (j_ref.obj()) {
 567       devtools_instrumentation::ScopedEmbedderCallbackTask embedder_callback(
 568           "onGeolocationPermissionsHidePrompt");
 569       Java_AwContents_onGeolocationPermissionsHidePrompt(env, j_ref.obj());
 570     }
 571     if (!pending_geolocation_prompts_.empty()) {
 572       ShowGeolocationPromptHelper(java_ref_,
 573                             pending_geolocation_prompts_.front().first);
 574     }
 575   }
 576 }
 577
 578 void AwContents::FindAllAsync(JNIEnv* env, jobject obj, jstring search_string) {
 579   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 580   GetFindHelper()->FindAllAsync(ConvertJavaStringToUTF16(env, search_string));
 581 }
 582
 583 void AwContents::FindNext(JNIEnv* env, jobject obj, jboolean forward) {
 584   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 585   GetFindHelper()->FindNext(forward);
 586 }
 587
 588 void AwContents::ClearMatches(JNIEnv* env, jobject obj) {
 589   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 590   GetFindHelper()->ClearMatches();
 591 }
 592
 593 void AwContents::ClearCache(
 594     JNIEnv* env,
 595     jobject obj,
 596     jboolean include_disk_files) {
 597   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 598   render_view_host_ext_->ClearCache();
 599
 600   if (include_disk_files) {
 601     RemoveHttpDiskCache(web_contents_->GetBrowserContext(),
 602                         web_contents_->GetRoutingID());
 603   }
 604 }
 605
 606 FindHelper* AwContents::GetFindHelper() {
 607   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 608   if (!find_helper_.get()) {
 609     find_helper_.reset(new FindHelper(web_contents_.get()));
 610     find_helper_->SetListener(this);
 611   }
 612   return find_helper_.get();
 613 }
 614
 615 void AwContents::OnFindResultReceived(int active_ordinal,
 616                                       int match_count,
 617                                       bool finished) {
 618   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 619   JNIEnv* env = AttachCurrentThread();
 620   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
 621   if (obj.is_null())
 622     return;
 623
 624   Java_AwContents_onFindResultReceived(
 625       env, obj.obj(), active_ordinal, match_count, finished);
 626 }
 627
 628 bool AwContents::ShouldDownloadFavicon(const GURL& icon_url) {
 629   return g_should_download_favicons;
 630 }
 631
 632 void AwContents::OnReceivedIcon(const GURL& icon_url, const SkBitmap& bitmap) {
 633   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 634   JNIEnv* env = AttachCurrentThread();
 635   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
 636   if (obj.is_null())
 637     return;
 638
 639   content::NavigationEntry* entry =
 640       web_contents_->GetController().GetActiveEntry();
 641
 642   if (entry) {
 643     entry->GetFavicon().valid = true;
 644     entry->GetFavicon().url = icon_url;
 645     entry->GetFavicon().image = gfx::Image::CreateFrom1xBitmap(bitmap);
 646   }
 647
 648   Java_AwContents_onReceivedIcon(
 649       env, obj.obj(), gfx::ConvertToJavaBitmap(&bitmap).obj());
 650 }
 651
 652 void AwContents::OnReceivedTouchIconUrl(const std::string& url,
 653                                         bool precomposed) {
 654   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 655   JNIEnv* env = AttachCurrentThread();
 656   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
 657   if (obj.is_null())
 658     return;
 659
 660   Java_AwContents_onReceivedTouchIconUrl(
 661       env, obj.obj(), ConvertUTF8ToJavaString(env, url).obj(), precomposed);
 662 }
 663
 664 bool AwContents::RequestDrawGL(jobject canvas) {
 665   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 666   JNIEnv* env = AttachCurrentThread();
 667   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
 668   if (obj.is_null())
 669     return false;
 670   return Java_AwContents_requestDrawGL(env, obj.obj(), canvas);
 671 }
 672
 673 void AwContents::PostInvalidate() {
 674   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 675   JNIEnv* env = AttachCurrentThread();
 676   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
 677   if (!obj.is_null())
 678     Java_AwContents_postInvalidateOnAnimation(env, obj.obj());
 679 }
 680
 681 void AwContents::OnNewPicture() {
 682   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 683   JNIEnv* env = AttachCurrentThread();
 684   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
 685   if (!obj.is_null()) {
 686     devtools_instrumentation::ScopedEmbedderCallbackTask embedder_callback(
 687         "onNewPicture");
 688     Java_AwContents_onNewPicture(env, obj.obj());
 689   }
 690 }
 691
 692 base::android::ScopedJavaLocalRef<jbyteArray>
 693     AwContents::GetCertificate(JNIEnv* env,
 694                                jobject obj) {
 695   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 696   content::NavigationEntry* entry =
 697       web_contents_->GetController().GetActiveEntry();
 698   if (!entry)
 699     return ScopedJavaLocalRef<jbyteArray>();
 700   // Get the certificate
 701   int cert_id = entry->GetSSL().cert_id;
 702   scoped_refptr<net::X509Certificate> cert;
 703   bool ok = content::CertStore::GetInstance()->RetrieveCert(cert_id, &cert);
 704   if (!ok)
 705     return ScopedJavaLocalRef<jbyteArray>();
 706
 707   // Convert the certificate and return it
 708   std::string der_string;
 709   net::X509Certificate::GetDEREncoded(cert->os_cert_handle(), &der_string);
 710   return base::android::ToJavaByteArray(env,
 711       reinterpret_cast<const uint8*>(der_string.data()), der_string.length());
 712 }
 713
 714 void AwContents::RequestNewHitTestDataAt(JNIEnv* env, jobject obj,
 715                                          jint x, jint y) {
 716   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 717   render_view_host_ext_->RequestNewHitTestDataAt(x, y);
 718 }
 719
 720 void AwContents::UpdateLastHitTestData(JNIEnv* env, jobject obj) {
 721   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 722   if (!render_view_host_ext_->HasNewHitTestData()) return;
 723
 724   const AwHitTestData& data = render_view_host_ext_->GetLastHitTestData();
 725   render_view_host_ext_->MarkHitTestDataRead();
 726
 727   // Make sure to null the Java object if data is empty/invalid.
 728   ScopedJavaLocalRef<jstring> extra_data_for_type;
 729   if (data.extra_data_for_type.length())
 730     extra_data_for_type = ConvertUTF8ToJavaString(
 731         env, data.extra_data_for_type);
 732
 733   ScopedJavaLocalRef<jstring> href;
 734   if (data.href.length())
 735     href = ConvertUTF16ToJavaString(env, data.href);
 736
 737   ScopedJavaLocalRef<jstring> anchor_text;
 738   if (data.anchor_text.length())
 739     anchor_text = ConvertUTF16ToJavaString(env, data.anchor_text);
 740
 741   ScopedJavaLocalRef<jstring> img_src;
 742   if (data.img_src.is_valid())
 743     img_src = ConvertUTF8ToJavaString(env, data.img_src.spec());
 744
 745   Java_AwContents_updateHitTestData(env,
 746                                     obj,
 747                                     data.type,
 748                                     extra_data_for_type.obj(),
 749                                     href.obj(),
 750                                     anchor_text.obj(),
 751                                     img_src.obj());
 752 }
 753
 754 void AwContents::OnSizeChanged(JNIEnv* env, jobject obj,
 755                                int w, int h, int ow, int oh) {
 756   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 757   browser_view_renderer_.OnSizeChanged(w, h);
 758 }
 759
 760 void AwContents::SetViewVisibility(JNIEnv* env, jobject obj, bool visible) {
 761   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 762   browser_view_renderer_.SetViewVisibility(visible);
 763 }
 764
 765 void AwContents::SetWindowVisibility(JNIEnv* env, jobject obj, bool visible) {
 766   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 767   browser_view_renderer_.SetWindowVisibility(visible);
 768 }
 769
 770 void AwContents::SetIsPaused(JNIEnv* env, jobject obj, bool paused) {
 771   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 772   browser_view_renderer_.SetIsPaused(paused);
 773   ContentViewCore* cvc =
 774       ContentViewCore::FromWebContents(web_contents_.get());
 775   if (cvc) {
 776     cvc->PauseOrResumeGeolocation(paused);
 777     if (paused) {
 778       cvc->PauseVideo();
 779     }
 780   }
 781 }
 782
 783 void AwContents::OnAttachedToWindow(JNIEnv* env, jobject obj, int w, int h) {
 784   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 785   browser_view_renderer_.OnAttachedToWindow(w, h);
 786 }
 787
 788 void AwContents::OnDetachedFromWindow(JNIEnv* env, jobject obj) {
 789   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 790   browser_view_renderer_.OnDetachedFromWindow();
 791 }
 792
 793 void AwContents::ReleaseHardwareDrawOnRenderThread(JNIEnv* env, jobject obj) {
 794   hardware_renderer_.reset();
 795 }
 796
 797 base::android::ScopedJavaLocalRef<jbyteArray>
 798 AwContents::GetOpaqueState(JNIEnv* env, jobject obj) {
 799   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 800   // Required optimization in WebViewClassic to not save any state if
 801   // there has been no navigations.
 802   if (!web_contents_->GetController().GetEntryCount())
 803     return ScopedJavaLocalRef<jbyteArray>();
 804
 805   Pickle pickle;
 806   if (!WriteToPickle(*web_contents_, &pickle)) {
 807     return ScopedJavaLocalRef<jbyteArray>();
 808   } else {
 809     return base::android::ToJavaByteArray(env,
 810        reinterpret_cast<const uint8*>(pickle.data()), pickle.size());
 811   }
 812 }
 813
 814 jboolean AwContents::RestoreFromOpaqueState(
 815     JNIEnv* env, jobject obj, jbyteArray state) {
 816   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 817   // TODO(boliu): This copy can be optimized out if this is a performance
 818   // problem.
 819   std::vector<uint8> state_vector;
 820   base::android::JavaByteArrayToByteVector(env, state, &state_vector);
 821
 822   Pickle pickle(reinterpret_cast<const char*>(state_vector.begin()),
 823                 state_vector.size());
 824   PickleIterator iterator(pickle);
 825
 826   return RestoreFromPickle(&iterator, web_contents_.get());
 827 }
 828
 829 bool AwContents::OnDraw(JNIEnv* env,
 830                         jobject obj,
 831                         jobject canvas,
 832                         jboolean is_hardware_accelerated,
 833                         jint scroll_x,
 834                         jint scroll_y,
 835                         jint visible_left,
 836                         jint visible_top,
 837                         jint visible_right,
 838                         jint visible_bottom,
 839                         jint clip_left,
 840                         jint clip_top,
 841                         jint clip_right,
 842                         jint clip_bottom) {
 843   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 844   return browser_view_renderer_.OnDraw(
 845       canvas,
 846       is_hardware_accelerated,
 847       gfx::Vector2d(scroll_x, scroll_y),
 848       gfx::Rect(visible_left,
 849                 visible_top,
 850                 visible_right - visible_left,
 851                 visible_bottom - visible_top),
 852       gfx::Rect(
 853           clip_left, clip_top, clip_right - clip_left, clip_bottom - clip_top));
 854 }
 855
 856 void AwContents::SetPendingWebContentsForPopup(
 857     scoped_ptr<content::WebContents> pending) {
 858   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 859   if (pending_contents_.get()) {
 860     // TODO(benm): Support holding multiple pop up window requests.
 861     LOG(WARNING) << "Blocking popup window creation as an outstanding "
 862                  << "popup window is still pending.";
 863     base::MessageLoop::current()->DeleteSoon(FROM_HERE, pending.release());
 864     return;
 865   }
 866   pending_contents_.reset(new AwContents(pending.Pass()));
 867 }
 868
 869 void AwContents::FocusFirstNode(JNIEnv* env, jobject obj) {
 870   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 871   web_contents_->FocusThroughTabTraversal(false);
 872 }
 873
 874 void AwContents::SetBackgroundColor(JNIEnv* env, jobject obj, jint color) {
 875   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 876   render_view_host_ext_->SetBackgroundColor(color);
 877 }
 878
 879 jint AwContents::ReleasePopupAwContents(JNIEnv* env, jobject obj) {
 880   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 881   return reinterpret_cast<jint>(pending_contents_.release());
 882 }
 883
 884 gfx::Point AwContents::GetLocationOnScreen() {
 885   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 886   JNIEnv* env = AttachCurrentThread();
 887   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
 888   if (obj.is_null())
 889     return gfx::Point();
 890   std::vector<int> location;
 891   base::android::JavaIntArrayToIntVector(
 892       env,
 893       Java_AwContents_getLocationOnScreen(env, obj.obj()).obj(),
 894       &location);
 895   return gfx::Point(location[0], location[1]);
 896 }
 897
 898 void AwContents::SetMaxContainerViewScrollOffset(gfx::Vector2d new_value) {
 899   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 900   JNIEnv* env = AttachCurrentThread();
 901   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
 902   if (obj.is_null())
 903     return;
 904   Java_AwContents_setMaxContainerViewScrollOffset(
 905       env, obj.obj(), new_value.x(), new_value.y());
 906 }
 907
 908 void AwContents::ScrollContainerViewTo(gfx::Vector2d new_value) {
 909   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 910   JNIEnv* env = AttachCurrentThread();
 911   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
 912   if (obj.is_null())
 913     return;
 914   Java_AwContents_scrollContainerViewTo(
 915       env, obj.obj(), new_value.x(), new_value.y());
 916 }
 917
 918 bool AwContents::IsFlingActive() const {
 919   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 920   JNIEnv* env = AttachCurrentThread();
 921   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
 922   if (obj.is_null())
 923     return false;
 924   return Java_AwContents_isFlingActive(env, obj.obj());
 925 }
 926
 927 void AwContents::SetPageScaleFactorAndLimits(
 928     float page_scale_factor,
 929     float min_page_scale_factor,
 930     float max_page_scale_factor) {
 931   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 932   JNIEnv* env = AttachCurrentThread();
 933   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
 934   if (obj.is_null())
 935     return;
 936   Java_AwContents_setPageScaleFactorAndLimits(env,
 937                                               obj.obj(),
 938                                               page_scale_factor,
 939                                               min_page_scale_factor,
 940                                               max_page_scale_factor);
 941 }
 942
 943 void AwContents::SetContentsSize(gfx::SizeF contents_size_dip) {
 944   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 945   JNIEnv* env = AttachCurrentThread();
 946   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
 947   if (obj.is_null())
 948     return;
 949   Java_AwContents_setContentsSize(
 950       env, obj.obj(), contents_size_dip.width(), contents_size_dip.height());
 951 }
 952
 953 void AwContents::DidOverscroll(gfx::Vector2d overscroll_delta) {
 954   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 955   JNIEnv* env = AttachCurrentThread();
 956   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
 957   if (obj.is_null())
 958     return;
 959   Java_AwContents_didOverscroll(
 960       env, obj.obj(), overscroll_delta.x(), overscroll_delta.y());
 961 }
 962
 963 const BrowserViewRenderer* AwContents::GetBrowserViewRenderer() const {
 964   return &browser_view_renderer_;
 965 }
 966
 967 void AwContents::SetDipScale(JNIEnv* env, jobject obj, jfloat dip_scale) {
 968   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 969   browser_view_renderer_.SetDipScale(dip_scale);
 970 }
 971
 972 void AwContents::SetFixedLayoutSize(JNIEnv* env,
 973                                     jobject obj,
 974                                     jint width_dip,
 975                                     jint height_dip) {
 976   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 977   render_view_host_ext_->SetFixedLayoutSize(gfx::Size(width_dip, height_dip));
 978 }
 979
 980 void AwContents::ScrollTo(JNIEnv* env, jobject obj, jint x, jint y) {
 981   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 982   browser_view_renderer_.ScrollTo(gfx::Vector2d(x, y));
 983 }
 984
 985 void AwContents::OnWebLayoutPageScaleFactorChanged(float page_scale_factor) {
 986   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 987   JNIEnv* env = AttachCurrentThread();
 988   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
 989   if (obj.is_null())
 990     return;
 991   Java_AwContents_onWebLayoutPageScaleFactorChanged(env, obj.obj(),
 992                                                          page_scale_factor);
 993 }
 994
 995 void AwContents::OnWebLayoutContentsSizeChanged(
 996     const gfx::Size& contents_size) {
 997   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 998   JNIEnv* env = AttachCurrentThread();
 999   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
1000   if (obj.is_null())
1001     return;
1002   Java_AwContents_onWebLayoutContentsSizeChanged(
1003       env, obj.obj(), contents_size.width(), contents_size.height());
1004 }
1005
1006 jlong AwContents::CapturePicture(JNIEnv* env,
1007                                  jobject obj,
1008                                  int width,
1009                                  int height) {
1010   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1011   return reinterpret_cast<intptr_t>(
1012       new AwPicture(browser_view_renderer_.CapturePicture(width, height)));
1013 }
1014
1015 void AwContents::EnableOnNewPicture(JNIEnv* env,
1016                                     jobject obj,
1017                                     jboolean enabled) {
1018   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1019   browser_view_renderer_.EnableOnNewPicture(enabled);
1020 }
1021
1022 void AwContents::ClearView(JNIEnv* env, jobject obj) {
1023   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1024   browser_view_renderer_.ClearView();
1025 }
1026
1027 void AwContents::SetExtraHeadersForUrl(JNIEnv* env, jobject obj,
1028                                        jstring url, jstring jextra_headers) {
1029   std::string extra_headers;
1030   if (jextra_headers)
1031     extra_headers = ConvertJavaStringToUTF8(env, jextra_headers);
1032   AwResourceContext* resource_context = static_cast<AwResourceContext*>(
1033       AwBrowserContext::FromWebContents(web_contents_.get())->
1034       GetResourceContext());
1035   resource_context->SetExtraHeaders(GURL(ConvertJavaStringToUTF8(env, url)),
1036                                     extra_headers);
1037 }
1038
1039 void AwContents::SetJsOnlineProperty(JNIEnv* env,
1040                                      jobject obj,
1041                                      jboolean network_up) {
1042   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1043   render_view_host_ext_->SetJsOnlineProperty(network_up);
1044 }
1045
1046 void AwContents::TrimMemoryOnRenderThread(JNIEnv* env,
1047                                           jobject obj,
1048                                           jint level,
1049                                           jboolean visible) {
1050   if (hardware_renderer_) {
1051     if (hardware_renderer_->TrimMemory(level, visible)) {
1052       content::BrowserThread::PostTask(
1053           content::BrowserThread::UI,
1054           FROM_HERE,
1055           base::Bind(&AwContents::ForceFakeComposite, ui_thread_weak_ptr_));
1056     }
1057   }
1058 }
1059
1060 void AwContents::ForceFakeComposite() {
1061   browser_view_renderer_.ForceFakeCompositeSW();
1062 }
1063
1064 void SetShouldDownloadFavicons(JNIEnv* env, jclass jclazz) {
1065   g_should_download_favicons = true;
1066 }
1067
1068 }  // namespace android_webview