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/deferred_gpu_command_service.h"
  14 #include "android_webview/browser/net_disk_cache_remover.h"
  15 #include "android_webview/browser/renderer_host/aw_resource_dispatcher_host_delegate.h"
  16 #include "android_webview/browser/scoped_app_gl_state_restore.h"
  17 #include "android_webview/browser/shared_renderer_state.h"
  18 #include "android_webview/common/aw_hit_test_data.h"
  19 #include "android_webview/common/devtools_instrumentation.h"
  20 #include "android_webview/native/aw_autofill_client.h"
  21 #include "android_webview/native/aw_browser_dependency_factory.h"
  22 #include "android_webview/native/aw_contents_client_bridge.h"
  23 #include "android_webview/native/aw_contents_io_thread_client_impl.h"
  24 #include "android_webview/native/aw_message_port_service_impl.h"
  25 #include "android_webview/native/aw_pdf_exporter.h"
  26 #include "android_webview/native/aw_picture.h"
  27 #include "android_webview/native/aw_web_contents_delegate.h"
  28 #include "android_webview/native/java_browser_view_renderer_helper.h"
  29 #include "android_webview/native/permission/aw_permission_request.h"
  30 #include "android_webview/native/permission/permission_request_handler.h"
  31 #include "android_webview/native/permission/simple_permission_request.h"
  32 #include "android_webview/native/state_serializer.h"
  33 #include "android_webview/public/browser/draw_gl.h"
  34 #include "base/android/jni_android.h"
  35 #include "base/android/jni_array.h"
  36 #include "base/android/jni_string.h"
  37 #include "base/android/locale_utils.h"
  38 #include "base/android/scoped_java_ref.h"
  39 #include "base/atomicops.h"
  40 #include "base/bind.h"
  41 #include "base/callback.h"
  42 #include "base/memory/memory_pressure_listener.h"
  43 #include "base/message_loop/message_loop.h"
  44 #include "base/pickle.h"
  45 #include "base/strings/string16.h"
  46 #include "base/supports_user_data.h"
  47 #include "components/autofill/content/browser/content_autofill_driver_factory.h"
  48 #include "components/autofill/core/browser/autofill_manager.h"
  49 #include "components/autofill/core/browser/webdata/autofill_webdata_service.h"
  50 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_settings.h"
  51 #include "components/navigation_interception/intercept_navigation_delegate.h"
  52 #include "content/public/browser/android/content_view_core.h"
  53 #include "content/public/browser/android/synchronous_compositor.h"
  54 #include "content/public/browser/browser_thread.h"
  55 #include "content/public/browser/cert_store.h"
  56 #include "content/public/browser/favicon_status.h"
  57 #include "content/public/browser/message_port_provider.h"
  58 #include "content/public/browser/navigation_entry.h"
  59 #include "content/public/browser/render_frame_host.h"
  60 #include "content/public/browser/render_process_host.h"
  61 #include "content/public/browser/render_view_host.h"
  62 #include "content/public/browser/web_contents.h"
  63 #include "content/public/common/message_port_types.h"
  64 #include "content/public/common/renderer_preferences.h"
  65 #include "content/public/common/ssl_status.h"
  66 #include "jni/AwContents_jni.h"
  67 #include "net/base/auth.h"
  68 #include "net/cert/x509_certificate.h"
  69 #include "third_party/skia/include/core/SkPicture.h"
  70 #include "ui/gfx/android/java_bitmap.h"
  71 #include "ui/gfx/geometry/rect_f.h"
  72 #include "ui/gfx/geometry/size.h"
  73 #include "ui/gfx/image/image.h"
  74
  75 struct AwDrawSWFunctionTable;
  76
  77 using autofill::ContentAutofillDriverFactory;
  78 using autofill::AutofillManager;
  79 using base::android::AttachCurrentThread;
  80 using base::android::ConvertJavaStringToUTF16;
  81 using base::android::ConvertJavaStringToUTF8;
  82 using base::android::ConvertUTF16ToJavaString;
  83 using base::android::ConvertUTF8ToJavaString;
  84 using base::android::JavaRef;
  85 using base::android::ScopedJavaGlobalRef;
  86 using base::android::ScopedJavaLocalRef;
  87 using data_reduction_proxy::DataReductionProxySettings;
  88 using navigation_interception::InterceptNavigationDelegate;
  89 using content::BrowserThread;
  90 using content::ContentViewCore;
  91 using content::WebContents;
  92
  93 extern "C" {
  94 static AwDrawGLFunction DrawGLFunction;
  95 static void DrawGLFunction(long view_context,
  96                            AwDrawGLInfo* draw_info,
  97                            void* spare) {
  98   // |view_context| is the value that was returned from the java
  99   // AwContents.onPrepareDrawGL; this cast must match the code there.
 100   reinterpret_cast<android_webview::SharedRendererState*>(view_context)
 101       ->DrawGL(draw_info);
 102 }
 103 }
 104
 105 namespace android_webview {
 106
 107 namespace {
 108
 109 bool g_should_download_favicons = false;
 110
 111 bool g_force_auxiliary_bitmap_rendering = false;
 112
 113 const void* kAwContentsUserDataKey = &kAwContentsUserDataKey;
 114
 115 class AwContentsUserData : public base::SupportsUserData::Data {
 116  public:
 117   AwContentsUserData(AwContents* ptr) : contents_(ptr) {}
 118
 119   static AwContents* GetContents(WebContents* web_contents) {
 120     if (!web_contents)
 121       return NULL;
 122     AwContentsUserData* data = static_cast<AwContentsUserData*>(
 123         web_contents->GetUserData(kAwContentsUserDataKey));
 124     return data ? data->contents_ : NULL;
 125   }
 126
 127  private:
 128   AwContents* contents_;
 129 };
 130
 131 base::subtle::Atomic32 g_instance_count = 0;
 132
 133 void OnIoThreadClientReady(content::RenderFrameHost* rfh) {
 134   int render_process_id = rfh->GetProcess()->GetID();
 135   int render_frame_id = rfh->GetRoutingID();
 136   AwResourceDispatcherHostDelegate::OnIoThreadClientReady(
 137       render_process_id, render_frame_id);
 138 }
 139
 140 }  // namespace
 141
 142 // static
 143 AwContents* AwContents::FromWebContents(WebContents* web_contents) {
 144   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 145   return AwContentsUserData::GetContents(web_contents);
 146 }
 147
 148 // static
 149 AwContents* AwContents::FromID(int render_process_id, int render_view_id) {
 150   const content::RenderViewHost* rvh =
 151       content::RenderViewHost::FromID(render_process_id, render_view_id);
 152   if (!rvh) return NULL;
 153   content::WebContents* web_contents =
 154       content::WebContents::FromRenderViewHost(rvh);
 155   if (!web_contents) return NULL;
 156   return FromWebContents(web_contents);
 157 }
 158
 159 // static
 160 AwBrowserPermissionRequestDelegate* AwBrowserPermissionRequestDelegate::FromID(
 161     int render_process_id, int render_frame_id) {
 162   AwContents* aw_contents = AwContents::FromWebContents(
 163       content::WebContents::FromRenderFrameHost(
 164           content::RenderFrameHost::FromID(render_process_id,
 165                                            render_frame_id)));
 166   return implicit_cast<AwBrowserPermissionRequestDelegate*>(aw_contents);
 167 }
 168
 169 AwContents::AwContents(scoped_ptr<WebContents> web_contents)
 170     : web_contents_(web_contents.Pass()),
 171       browser_view_renderer_(
 172           this,
 173           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI)),
 174       renderer_manager_key_(GLViewRendererManager::GetInstance()->NullKey()) {
 175   base::subtle::NoBarrier_AtomicIncrement(&g_instance_count, 1);
 176   icon_helper_.reset(new IconHelper(web_contents_.get()));
 177   icon_helper_->SetListener(this);
 178   web_contents_->SetUserData(android_webview::kAwContentsUserDataKey,
 179                              new AwContentsUserData(this));
 180   browser_view_renderer_.RegisterWithWebContents(web_contents_.get());
 181   render_view_host_ext_.reset(
 182       new AwRenderViewHostExt(this, web_contents_.get()));
 183
 184   permission_request_handler_.reset(
 185       new PermissionRequestHandler(this, web_contents_.get()));
 186
 187   AwAutofillClient* autofill_manager_delegate =
 188       AwAutofillClient::FromWebContents(web_contents_.get());
 189   InitDataReductionProxyIfNecessary();
 190   if (autofill_manager_delegate)
 191     InitAutofillIfNecessary(autofill_manager_delegate->GetSaveFormData());
 192   content::SynchronousCompositor::SetClientForWebContents(
 193       web_contents_.get(), &browser_view_renderer_);
 194 }
 195
 196 void AwContents::SetJavaPeers(JNIEnv* env,
 197                               jobject obj,
 198                               jobject aw_contents,
 199                               jobject web_contents_delegate,
 200                               jobject contents_client_bridge,
 201                               jobject io_thread_client,
 202                               jobject intercept_navigation_delegate) {
 203   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 204   // The |aw_content| param is technically spurious as it duplicates |obj| but
 205   // is passed over anyway to make the binding more explicit.
 206   java_ref_ = JavaObjectWeakGlobalRef(env, aw_contents);
 207
 208   web_contents_delegate_.reset(
 209       new AwWebContentsDelegate(env, web_contents_delegate));
 210   web_contents_->SetDelegate(web_contents_delegate_.get());
 211
 212   contents_client_bridge_.reset(
 213       new AwContentsClientBridge(env, contents_client_bridge));
 214   AwContentsClientBridgeBase::Associate(web_contents_.get(),
 215                                         contents_client_bridge_.get());
 216
 217   AwContentsIoThreadClientImpl::Associate(
 218       web_contents_.get(), ScopedJavaLocalRef<jobject>(env, io_thread_client));
 219
 220   InterceptNavigationDelegate::Associate(
 221       web_contents_.get(),
 222       make_scoped_ptr(new InterceptNavigationDelegate(
 223           env, intercept_navigation_delegate)));
 224
 225   // Finally, having setup the associations, release any deferred requests
 226   web_contents_->ForEachFrame(base::Bind(&OnIoThreadClientReady));
 227 }
 228
 229 void AwContents::SetSaveFormData(bool enabled) {
 230   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 231   InitAutofillIfNecessary(enabled);
 232   // We need to check for the existence, since autofill_manager_delegate
 233   // may not be created when the setting is false.
 234   if (AwAutofillClient::FromWebContents(web_contents_.get())) {
 235     AwAutofillClient::FromWebContents(web_contents_.get())->
 236         SetSaveFormData(enabled);
 237   }
 238 }
 239
 240 void AwContents::InitDataReductionProxyIfNecessary() {
 241   AwBrowserContext* browser_context =
 242       AwBrowserContext::FromWebContents(web_contents_.get());
 243   browser_context->CreateUserPrefServiceIfNecessary();
 244 }
 245
 246 void AwContents::InitAutofillIfNecessary(bool enabled) {
 247   // Do not initialize if the feature is not enabled.
 248   if (!enabled)
 249     return;
 250   // Check if the autofill driver factory already exists.
 251   content::WebContents* web_contents = web_contents_.get();
 252   if (ContentAutofillDriverFactory::FromWebContents(web_contents))
 253     return;
 254
 255   AwBrowserContext::FromWebContents(web_contents)->
 256       CreateUserPrefServiceIfNecessary();
 257   AwAutofillClient::CreateForWebContents(web_contents);
 258   ContentAutofillDriverFactory::CreateForWebContentsAndDelegate(
 259       web_contents, AwAutofillClient::FromWebContents(web_contents),
 260       base::android::GetDefaultLocale(),
 261       AutofillManager::DISABLE_AUTOFILL_DOWNLOAD_MANAGER);
 262 }
 263
 264 void AwContents::SetAwAutofillClient(jobject client) {
 265   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 266   JNIEnv* env = AttachCurrentThread();
 267   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
 268   if (obj.is_null())
 269     return;
 270   Java_AwContents_setAwAutofillClient(env, obj.obj(), client);
 271 }
 272
 273 AwContents::~AwContents() {
 274   DCHECK_EQ(this, AwContents::FromWebContents(web_contents_.get()));
 275   content::SynchronousCompositor::SetClientForWebContents(web_contents_.get(),
 276                                                           NULL);
 277   web_contents_->RemoveUserData(kAwContentsUserDataKey);
 278   if (find_helper_.get())
 279     find_helper_->SetListener(NULL);
 280   if (icon_helper_.get())
 281     icon_helper_->SetListener(NULL);
 282   base::subtle::NoBarrier_AtomicIncrement(&g_instance_count, -1);
 283   // When the last WebView is destroyed free all discardable memory allocated by
 284   // Chromium, because the app process may continue to run for a long time
 285   // without ever using another WebView.
 286   if (base::subtle::NoBarrier_Load(&g_instance_count) == 0) {
 287     base::MemoryPressureListener::NotifyMemoryPressure(
 288         base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL);
 289   }
 290 }
 291
 292 base::android::ScopedJavaLocalRef<jobject>
 293 AwContents::GetWebContents(JNIEnv* env, jobject obj) {
 294   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 295   DCHECK(web_contents_);
 296   if (!web_contents_)
 297     return base::android::ScopedJavaLocalRef<jobject>();
 298
 299   return web_contents_->GetJavaWebContents();
 300 }
 301
 302 void AwContents::Destroy(JNIEnv* env, jobject obj) {
 303   java_ref_.reset();
 304   delete this;
 305 }
 306
 307 static jlong Init(JNIEnv* env, jclass, jobject browser_context) {
 308   // TODO(joth): Use |browser_context| to get the native BrowserContext, rather
 309   // than hard-code the default instance lookup here.
 310   scoped_ptr<WebContents> web_contents(content::WebContents::Create(
 311       content::WebContents::CreateParams(AwBrowserContext::GetDefault())));
 312   // Return an 'uninitialized' instance; most work is deferred until the
 313   // subsequent SetJavaPeers() call.
 314   return reinterpret_cast<intptr_t>(new AwContents(web_contents.Pass()));
 315 }
 316
 317 static void SetForceAuxiliaryBitmapRendering(
 318     JNIEnv* env,
 319     jclass,
 320     jboolean force_auxiliary_bitmap_rendering) {
 321   g_force_auxiliary_bitmap_rendering = force_auxiliary_bitmap_rendering;
 322 }
 323
 324 static void SetAwDrawSWFunctionTable(JNIEnv* env, jclass,
 325                                      jlong function_table) {
 326   RasterHelperSetAwDrawSWFunctionTable(
 327       reinterpret_cast<AwDrawSWFunctionTable*>(function_table));
 328 }
 329
 330 static void SetAwDrawGLFunctionTable(JNIEnv* env, jclass,
 331                                      jlong function_table) {
 332 }
 333
 334 static jlong GetAwDrawGLFunction(JNIEnv* env, jclass) {
 335   return reinterpret_cast<intptr_t>(&DrawGLFunction);
 336 }
 337
 338 // static
 339 jint GetNativeInstanceCount(JNIEnv* env, jclass) {
 340   return base::subtle::NoBarrier_Load(&g_instance_count);
 341 }
 342
 343 jlong AwContents::GetAwDrawGLViewContext(JNIEnv* env, jobject obj) {
 344   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 345   return reinterpret_cast<intptr_t>(
 346       browser_view_renderer_.GetAwDrawGLViewContext());
 347 }
 348
 349 namespace {
 350 void DocumentHasImagesCallback(const ScopedJavaGlobalRef<jobject>& message,
 351                                bool has_images) {
 352   Java_AwContents_onDocumentHasImagesResponse(AttachCurrentThread(),
 353                                               has_images,
 354                                               message.obj());
 355 }
 356 }  // namespace
 357
 358 void AwContents::DocumentHasImages(JNIEnv* env, jobject obj, jobject message) {
 359   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 360   ScopedJavaGlobalRef<jobject> j_message;
 361   j_message.Reset(env, message);
 362   render_view_host_ext_->DocumentHasImages(
 363       base::Bind(&DocumentHasImagesCallback, j_message));
 364 }
 365
 366 namespace {
 367 void GenerateMHTMLCallback(ScopedJavaGlobalRef<jobject>* callback,
 368                            const base::FilePath& path, int64 size) {
 369   JNIEnv* env = AttachCurrentThread();
 370   // Android files are UTF8, so the path conversion below is safe.
 371   Java_AwContents_generateMHTMLCallback(
 372       env,
 373       ConvertUTF8ToJavaString(env, path.AsUTF8Unsafe()).obj(),
 374       size, callback->obj());
 375 }
 376 }  // namespace
 377
 378 void AwContents::GenerateMHTML(JNIEnv* env, jobject obj,
 379                                jstring jpath, jobject callback) {
 380   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 381   ScopedJavaGlobalRef<jobject>* j_callback = new ScopedJavaGlobalRef<jobject>();
 382   j_callback->Reset(env, callback);
 383   base::FilePath target_path(ConvertJavaStringToUTF8(env, jpath));
 384   web_contents_->GenerateMHTML(
 385       target_path,
 386       base::Bind(&GenerateMHTMLCallback, base::Owned(j_callback), target_path));
 387 }
 388
 389 void AwContents::CreatePdfExporter(JNIEnv* env,
 390                                    jobject obj,
 391                                    jobject pdfExporter) {
 392   pdf_exporter_.reset(
 393       new AwPdfExporter(env,
 394                         pdfExporter,
 395                         web_contents_.get()));
 396 }
 397
 398 bool AwContents::OnReceivedHttpAuthRequest(const JavaRef<jobject>& handler,
 399                                            const std::string& host,
 400                                            const std::string& realm) {
 401   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 402   JNIEnv* env = AttachCurrentThread();
 403   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
 404   if (obj.is_null())
 405     return false;
 406
 407   ScopedJavaLocalRef<jstring> jhost = ConvertUTF8ToJavaString(env, host);
 408   ScopedJavaLocalRef<jstring> jrealm = ConvertUTF8ToJavaString(env, realm);
 409   devtools_instrumentation::ScopedEmbedderCallbackTask embedder_callback(
 410       "onReceivedHttpAuthRequest");
 411   Java_AwContents_onReceivedHttpAuthRequest(env, obj.obj(), handler.obj(),
 412       jhost.obj(), jrealm.obj());
 413   return true;
 414 }
 415
 416 void AwContents::SetOffscreenPreRaster(bool enabled) {
 417   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 418   browser_view_renderer_.SetOffscreenPreRaster(enabled);
 419 }
 420
 421 void AwContents::AddVisitedLinks(JNIEnv* env,
 422                                    jobject obj,
 423                                    jobjectArray jvisited_links) {
 424   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 425   std::vector<base::string16> visited_link_strings;
 426   base::android::AppendJavaStringArrayToStringVector(
 427       env, jvisited_links, &visited_link_strings);
 428
 429   std::vector<GURL> visited_link_gurls;
 430   std::vector<base::string16>::const_iterator itr;
 431   for (itr = visited_link_strings.begin(); itr != visited_link_strings.end();
 432        ++itr) {
 433     visited_link_gurls.push_back(GURL(*itr));
 434   }
 435
 436   AwBrowserContext::FromWebContents(web_contents_.get())
 437       ->AddVisitedURLs(visited_link_gurls);
 438 }
 439
 440 bool RegisterAwContents(JNIEnv* env) {
 441   return RegisterNativesImpl(env);
 442 }
 443
 444 namespace {
 445
 446 void ShowGeolocationPromptHelperTask(const JavaObjectWeakGlobalRef& java_ref,
 447                                      const GURL& origin) {
 448   JNIEnv* env = AttachCurrentThread();
 449   ScopedJavaLocalRef<jobject> j_ref = java_ref.get(env);
 450   if (j_ref.obj()) {
 451     ScopedJavaLocalRef<jstring> j_origin(
 452         ConvertUTF8ToJavaString(env, origin.spec()));
 453     devtools_instrumentation::ScopedEmbedderCallbackTask embedder_callback(
 454         "onGeolocationPermissionsShowPrompt");
 455     Java_AwContents_onGeolocationPermissionsShowPrompt(env,
 456                                                        j_ref.obj(),
 457                                                        j_origin.obj());
 458   }
 459 }
 460
 461 void ShowGeolocationPromptHelper(const JavaObjectWeakGlobalRef& java_ref,
 462                                  const GURL& origin) {
 463   JNIEnv* env = AttachCurrentThread();
 464   if (java_ref.get(env).obj()) {
 465     content::BrowserThread::PostTask(
 466         content::BrowserThread::UI,
 467         FROM_HERE,
 468         base::Bind(&ShowGeolocationPromptHelperTask,
 469                    java_ref,
 470                    origin));
 471   }
 472 }
 473
 474 } // anonymous namespace
 475
 476 void AwContents::ShowGeolocationPrompt(const GURL& requesting_frame,
 477                                        base::Callback<void(bool)> callback) {
 478   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 479
 480   GURL origin = requesting_frame.GetOrigin();
 481   bool show_prompt = pending_geolocation_prompts_.empty();
 482   pending_geolocation_prompts_.push_back(OriginCallback(origin, callback));
 483   if (show_prompt) {
 484     ShowGeolocationPromptHelper(java_ref_, origin);
 485   }
 486 }
 487
 488 // Invoked from Java
 489 void AwContents::InvokeGeolocationCallback(JNIEnv* env,
 490                                            jobject obj,
 491                                            jboolean value,
 492                                            jstring origin) {
 493   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 494   if (pending_geolocation_prompts_.empty()) {
 495     LOG(WARNING) << "Response for this geolocation request has been received."
 496                  << " Ignoring subsequent responses";
 497     return;
 498   }
 499
 500   GURL callback_origin(base::android::ConvertJavaStringToUTF16(env, origin));
 501   if (callback_origin.GetOrigin() ==
 502       pending_geolocation_prompts_.front().first) {
 503     pending_geolocation_prompts_.front().second.Run(value);
 504     pending_geolocation_prompts_.pop_front();
 505     if (!pending_geolocation_prompts_.empty()) {
 506       ShowGeolocationPromptHelper(java_ref_,
 507                                   pending_geolocation_prompts_.front().first);
 508     }
 509   } else {
 510     LOG(WARNING) << "Response for this geolocation request has been received."
 511                  << " Ignoring subsequent responses";
 512   }
 513 }
 514
 515 void AwContents::HideGeolocationPrompt(const GURL& origin) {
 516   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 517   bool removed_current_outstanding_callback = false;
 518   std::list<OriginCallback>::iterator it = pending_geolocation_prompts_.begin();
 519   while (it != pending_geolocation_prompts_.end()) {
 520     if ((*it).first == origin.GetOrigin()) {
 521       if (it == pending_geolocation_prompts_.begin()) {
 522         removed_current_outstanding_callback = true;
 523       }
 524       it = pending_geolocation_prompts_.erase(it);
 525     } else {
 526       ++it;
 527     }
 528   }
 529
 530   if (removed_current_outstanding_callback) {
 531     JNIEnv* env = AttachCurrentThread();
 532     ScopedJavaLocalRef<jobject> j_ref = java_ref_.get(env);
 533     if (j_ref.obj()) {
 534       devtools_instrumentation::ScopedEmbedderCallbackTask embedder_callback(
 535           "onGeolocationPermissionsHidePrompt");
 536       Java_AwContents_onGeolocationPermissionsHidePrompt(env, j_ref.obj());
 537     }
 538     if (!pending_geolocation_prompts_.empty()) {
 539       ShowGeolocationPromptHelper(java_ref_,
 540                             pending_geolocation_prompts_.front().first);
 541     }
 542   }
 543 }
 544
 545 void AwContents::OnPermissionRequest(
 546     base::android::ScopedJavaLocalRef<jobject> j_request,
 547     AwPermissionRequest* request) {
 548   DCHECK(!j_request.is_null());
 549   DCHECK(request);
 550
 551   JNIEnv* env = AttachCurrentThread();
 552   ScopedJavaLocalRef<jobject> j_ref = java_ref_.get(env);
 553   if (j_ref.is_null()) {
 554     permission_request_handler_->CancelRequest(request->GetOrigin(),
 555                                                request->GetResources());
 556     return;
 557   }
 558
 559   Java_AwContents_onPermissionRequest(env, j_ref.obj(), j_request.obj());
 560 }
 561
 562 void AwContents::OnPermissionRequestCanceled(AwPermissionRequest* request) {
 563   JNIEnv* env = AttachCurrentThread();
 564   ScopedJavaLocalRef<jobject> j_request = request->GetJavaObject();
 565   ScopedJavaLocalRef<jobject> j_ref = java_ref_.get(env);
 566   if (j_request.is_null() || j_ref.is_null())
 567     return;
 568
 569   Java_AwContents_onPermissionRequestCanceled(
 570       env, j_ref.obj(), j_request.obj());
 571 }
 572
 573 void AwContents::PreauthorizePermission(
 574     JNIEnv* env,
 575     jobject obj,
 576     jstring origin,
 577     jlong resources) {
 578   permission_request_handler_->PreauthorizePermission(
 579       GURL(base::android::ConvertJavaStringToUTF8(env, origin)), resources);
 580 }
 581
 582 void AwContents::RequestProtectedMediaIdentifierPermission(
 583     const GURL& origin,
 584     const base::Callback<void(bool)>& callback) {
 585   permission_request_handler_->SendRequest(
 586       scoped_ptr<AwPermissionRequestDelegate>(new SimplePermissionRequest(
 587           origin, AwPermissionRequest::ProtectedMediaId, callback)));
 588 }
 589
 590 void AwContents::CancelProtectedMediaIdentifierPermissionRequests(
 591     const GURL& origin) {
 592   permission_request_handler_->CancelRequest(
 593       origin, AwPermissionRequest::ProtectedMediaId);
 594 }
 595
 596 void AwContents::RequestGeolocationPermission(
 597     const GURL& origin,
 598     const base::Callback<void(bool)>& callback) {
 599   JNIEnv* env = AttachCurrentThread();
 600   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
 601   if (obj.is_null())
 602     return;
 603
 604   if (Java_AwContents_useLegacyGeolocationPermissionAPI(env, obj.obj())) {
 605     ShowGeolocationPrompt(origin, callback);
 606     return;
 607   }
 608   permission_request_handler_->SendRequest(
 609       scoped_ptr<AwPermissionRequestDelegate>(new SimplePermissionRequest(
 610           origin, AwPermissionRequest::Geolocation, callback)));
 611 }
 612
 613 void AwContents::CancelGeolocationPermissionRequests(const GURL& origin) {
 614   JNIEnv* env = AttachCurrentThread();
 615   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
 616   if (obj.is_null())
 617     return;
 618
 619   if (Java_AwContents_useLegacyGeolocationPermissionAPI(env, obj.obj())) {
 620     HideGeolocationPrompt(origin);
 621     return;
 622   }
 623   permission_request_handler_->CancelRequest(
 624       origin, AwPermissionRequest::Geolocation);
 625 }
 626
 627 void AwContents::RequestMIDISysexPermission(
 628     const GURL& origin,
 629     const base::Callback<void(bool)>& callback) {
 630   permission_request_handler_->SendRequest(
 631       scoped_ptr<AwPermissionRequestDelegate>(new SimplePermissionRequest(
 632           origin, AwPermissionRequest::MIDISysex, callback)));
 633 }
 634
 635 void AwContents::CancelMIDISysexPermissionRequests(const GURL& origin) {
 636   permission_request_handler_->CancelRequest(
 637       origin, AwPermissionRequest::AwPermissionRequest::MIDISysex);
 638 }
 639
 640 void AwContents::FindAllAsync(JNIEnv* env, jobject obj, jstring search_string) {
 641   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 642   GetFindHelper()->FindAllAsync(ConvertJavaStringToUTF16(env, search_string));
 643 }
 644
 645 void AwContents::FindNext(JNIEnv* env, jobject obj, jboolean forward) {
 646   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 647   GetFindHelper()->FindNext(forward);
 648 }
 649
 650 void AwContents::ClearMatches(JNIEnv* env, jobject obj) {
 651   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 652   GetFindHelper()->ClearMatches();
 653 }
 654
 655 void AwContents::ClearCache(
 656     JNIEnv* env,
 657     jobject obj,
 658     jboolean include_disk_files) {
 659   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 660   render_view_host_ext_->ClearCache();
 661
 662   if (include_disk_files) {
 663     RemoveHttpDiskCache(web_contents_->GetBrowserContext(),
 664                         web_contents_->GetRoutingID());
 665   }
 666 }
 667
 668 FindHelper* AwContents::GetFindHelper() {
 669   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 670   if (!find_helper_.get()) {
 671     find_helper_.reset(new FindHelper(web_contents_.get()));
 672     find_helper_->SetListener(this);
 673   }
 674   return find_helper_.get();
 675 }
 676
 677 void AwContents::OnFindResultReceived(int active_ordinal,
 678                                       int match_count,
 679                                       bool finished) {
 680   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 681   JNIEnv* env = AttachCurrentThread();
 682   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
 683   if (obj.is_null())
 684     return;
 685
 686   Java_AwContents_onFindResultReceived(
 687       env, obj.obj(), active_ordinal, match_count, finished);
 688 }
 689
 690 bool AwContents::ShouldDownloadFavicon(const GURL& icon_url) {
 691   return g_should_download_favicons;
 692 }
 693
 694 void AwContents::OnReceivedIcon(const GURL& icon_url, const SkBitmap& bitmap) {
 695   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 696   JNIEnv* env = AttachCurrentThread();
 697   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
 698   if (obj.is_null())
 699     return;
 700
 701   content::NavigationEntry* entry =
 702       web_contents_->GetController().GetLastCommittedEntry();
 703
 704   if (entry) {
 705     entry->GetFavicon().valid = true;
 706     entry->GetFavicon().url = icon_url;
 707     entry->GetFavicon().image = gfx::Image::CreateFrom1xBitmap(bitmap);
 708   }
 709
 710   Java_AwContents_onReceivedIcon(
 711       env, obj.obj(), gfx::ConvertToJavaBitmap(&bitmap).obj());
 712 }
 713
 714 void AwContents::OnReceivedTouchIconUrl(const std::string& url,
 715                                         bool precomposed) {
 716   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 717   JNIEnv* env = AttachCurrentThread();
 718   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
 719   if (obj.is_null())
 720     return;
 721
 722   Java_AwContents_onReceivedTouchIconUrl(
 723       env, obj.obj(), ConvertUTF8ToJavaString(env, url).obj(), precomposed);
 724 }
 725
 726 bool AwContents::RequestDrawGL(bool wait_for_completion) {
 727   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 728   JNIEnv* env = AttachCurrentThread();
 729   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
 730   if (obj.is_null())
 731     return false;
 732   return Java_AwContents_requestDrawGL(env, obj.obj(), wait_for_completion);
 733 }
 734
 735 void AwContents::PostInvalidate() {
 736   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 737   JNIEnv* env = AttachCurrentThread();
 738   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
 739   if (!obj.is_null())
 740     Java_AwContents_postInvalidateOnAnimation(env, obj.obj());
 741 }
 742
 743 void AwContents::OnNewPicture() {
 744   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 745   JNIEnv* env = AttachCurrentThread();
 746   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
 747   if (!obj.is_null()) {
 748     devtools_instrumentation::ScopedEmbedderCallbackTask embedder_callback(
 749         "onNewPicture");
 750     Java_AwContents_onNewPicture(env, obj.obj());
 751   }
 752 }
 753
 754 base::android::ScopedJavaLocalRef<jbyteArray> AwContents::GetCertificate(
 755     JNIEnv* env,
 756     jobject obj) {
 757   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 758   content::NavigationEntry* entry =
 759       web_contents_->GetController().GetLastCommittedEntry();
 760   if (!entry)
 761     return ScopedJavaLocalRef<jbyteArray>();
 762   // Get the certificate
 763   int cert_id = entry->GetSSL().cert_id;
 764   scoped_refptr<net::X509Certificate> cert;
 765   bool ok = content::CertStore::GetInstance()->RetrieveCert(cert_id, &cert);
 766   if (!ok)
 767     return ScopedJavaLocalRef<jbyteArray>();
 768
 769   // Convert the certificate and return it
 770   std::string der_string;
 771   net::X509Certificate::GetDEREncoded(cert->os_cert_handle(), &der_string);
 772   return base::android::ToJavaByteArray(env,
 773       reinterpret_cast<const uint8*>(der_string.data()), der_string.length());
 774 }
 775
 776 void AwContents::RequestNewHitTestDataAt(JNIEnv* env,
 777                                          jobject obj,
 778                                          jfloat x,
 779                                          jfloat y,
 780                                          jfloat touch_major) {
 781   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 782   gfx::PointF touch_center(x, y);
 783   gfx::SizeF touch_area(touch_major, touch_major);
 784   render_view_host_ext_->RequestNewHitTestDataAt(touch_center, touch_area);
 785 }
 786
 787 void AwContents::UpdateLastHitTestData(JNIEnv* env, jobject obj) {
 788   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 789   if (!render_view_host_ext_->HasNewHitTestData()) return;
 790
 791   const AwHitTestData& data = render_view_host_ext_->GetLastHitTestData();
 792   render_view_host_ext_->MarkHitTestDataRead();
 793
 794   // Make sure to null the Java object if data is empty/invalid.
 795   ScopedJavaLocalRef<jstring> extra_data_for_type;
 796   if (data.extra_data_for_type.length())
 797     extra_data_for_type = ConvertUTF8ToJavaString(
 798         env, data.extra_data_for_type);
 799
 800   ScopedJavaLocalRef<jstring> href;
 801   if (data.href.length())
 802     href = ConvertUTF16ToJavaString(env, data.href);
 803
 804   ScopedJavaLocalRef<jstring> anchor_text;
 805   if (data.anchor_text.length())
 806     anchor_text = ConvertUTF16ToJavaString(env, data.anchor_text);
 807
 808   ScopedJavaLocalRef<jstring> img_src;
 809   if (data.img_src.is_valid())
 810     img_src = ConvertUTF8ToJavaString(env, data.img_src.spec());
 811
 812   Java_AwContents_updateHitTestData(env,
 813                                     obj,
 814                                     data.type,
 815                                     extra_data_for_type.obj(),
 816                                     href.obj(),
 817                                     anchor_text.obj(),
 818                                     img_src.obj());
 819 }
 820
 821 void AwContents::OnSizeChanged(JNIEnv* env, jobject obj,
 822                                int w, int h, int ow, int oh) {
 823   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 824   browser_view_renderer_.OnSizeChanged(w, h);
 825 }
 826
 827 void AwContents::SetViewVisibility(JNIEnv* env, jobject obj, bool visible) {
 828   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 829   browser_view_renderer_.SetViewVisibility(visible);
 830 }
 831
 832 void AwContents::SetWindowVisibility(JNIEnv* env, jobject obj, bool visible) {
 833   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 834   browser_view_renderer_.SetWindowVisibility(visible);
 835 }
 836
 837 void AwContents::SetIsPaused(JNIEnv* env, jobject obj, bool paused) {
 838   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 839   browser_view_renderer_.SetIsPaused(paused);
 840   ContentViewCore* cvc =
 841       ContentViewCore::FromWebContents(web_contents_.get());
 842   if (cvc) {
 843     cvc->PauseOrResumeGeolocation(paused);
 844   }
 845 }
 846
 847 void AwContents::OnAttachedToWindow(JNIEnv* env, jobject obj, int w, int h) {
 848   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 849   browser_view_renderer_.OnAttachedToWindow(w, h);
 850 }
 851
 852 void AwContents::OnDetachedFromWindow(JNIEnv* env, jobject obj) {
 853   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 854   browser_view_renderer_.OnDetachedFromWindow();
 855 }
 856
 857 void AwContents::DetachFunctorFromView() {
 858   JNIEnv* env = AttachCurrentThread();
 859   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
 860   if (!obj.is_null())
 861     Java_AwContents_detachFunctorFromView(env, obj.obj());
 862 }
 863
 864 base::android::ScopedJavaLocalRef<jbyteArray>
 865 AwContents::GetOpaqueState(JNIEnv* env, jobject obj) {
 866   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 867   // Required optimization in WebViewClassic to not save any state if
 868   // there has been no navigations.
 869   if (!web_contents_->GetController().GetEntryCount())
 870     return ScopedJavaLocalRef<jbyteArray>();
 871
 872   base::Pickle pickle;
 873   if (!WriteToPickle(*web_contents_, &pickle)) {
 874     return ScopedJavaLocalRef<jbyteArray>();
 875   } else {
 876     return base::android::ToJavaByteArray(env,
 877        reinterpret_cast<const uint8*>(pickle.data()), pickle.size());
 878   }
 879 }
 880
 881 jboolean AwContents::RestoreFromOpaqueState(
 882     JNIEnv* env, jobject obj, jbyteArray state) {
 883   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 884   // TODO(boliu): This copy can be optimized out if this is a performance
 885   // problem.
 886   std::vector<uint8> state_vector;
 887   base::android::JavaByteArrayToByteVector(env, state, &state_vector);
 888
 889   base::Pickle pickle(reinterpret_cast<const char*>(state_vector.data()),
 890                       state_vector.size());
 891   base::PickleIterator iterator(pickle);
 892
 893   return RestoreFromPickle(&iterator, web_contents_.get());
 894 }
 895
 896 bool AwContents::OnDraw(JNIEnv* env,
 897                         jobject obj,
 898                         jobject canvas,
 899                         jboolean is_hardware_accelerated,
 900                         jint scroll_x,
 901                         jint scroll_y,
 902                         jint visible_left,
 903                         jint visible_top,
 904                         jint visible_right,
 905                         jint visible_bottom) {
 906   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 907   gfx::Vector2d scroll(scroll_x, scroll_y);
 908   browser_view_renderer_.PrepareToDraw(
 909       scroll, gfx::Rect(visible_left, visible_top, visible_right - visible_left,
 910                         visible_bottom - visible_top));
 911   if (is_hardware_accelerated && browser_view_renderer_.attached_to_window() &&
 912       !g_force_auxiliary_bitmap_rendering) {
 913     return browser_view_renderer_.OnDrawHardware();
 914   }
 915
 916   gfx::Size view_size = browser_view_renderer_.size();
 917   if (view_size.IsEmpty()) {
 918     TRACE_EVENT_INSTANT0("android_webview", "EarlyOut_EmptySize",
 919                          TRACE_EVENT_SCOPE_THREAD);
 920     return false;
 921   }
 922
 923   // TODO(hush): Right now webview size is passed in as the auxiliary bitmap
 924   // size, which might hurt performace (only for software draws with auxiliary
 925   // bitmap). For better performance, get global visible rect, transform it
 926   // from screen space to view space, then intersect with the webview in
 927   // viewspace.  Use the resulting rect as the auxiliary bitmap.
 928   scoped_ptr<SoftwareCanvasHolder> canvas_holder = SoftwareCanvasHolder::Create(
 929       canvas, scroll, view_size, g_force_auxiliary_bitmap_rendering);
 930   if (!canvas_holder || !canvas_holder->GetCanvas()) {
 931     TRACE_EVENT_INSTANT0("android_webview", "EarlyOut_EmptySize",
 932                          TRACE_EVENT_SCOPE_THREAD);
 933     return false;
 934   }
 935   return browser_view_renderer_.OnDrawSoftware(canvas_holder->GetCanvas());
 936 }
 937
 938 void AwContents::SetPendingWebContentsForPopup(
 939     scoped_ptr<content::WebContents> pending) {
 940   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 941   if (pending_contents_.get()) {
 942     // TODO(benm): Support holding multiple pop up window requests.
 943     LOG(WARNING) << "Blocking popup window creation as an outstanding "
 944                  << "popup window is still pending.";
 945     base::MessageLoop::current()->DeleteSoon(FROM_HERE, pending.release());
 946     return;
 947   }
 948   pending_contents_.reset(new AwContents(pending.Pass()));
 949   // Set dip_scale for pending contents, which is necessary for the later
 950   // SynchronousCompositor and InputHandler setup.
 951   pending_contents_->SetDipScaleInternal(browser_view_renderer_.dip_scale());
 952 }
 953
 954 void AwContents::FocusFirstNode(JNIEnv* env, jobject obj) {
 955   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 956   web_contents_->FocusThroughTabTraversal(false);
 957 }
 958
 959 void AwContents::SetBackgroundColor(JNIEnv* env, jobject obj, jint color) {
 960   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 961   render_view_host_ext_->SetBackgroundColor(color);
 962 }
 963
 964 void AwContents::OnComputeScroll(JNIEnv* env,
 965                                  jobject obj,
 966                                  jlong animation_time_millis) {
 967   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 968   browser_view_renderer_.OnComputeScroll(
 969       base::TimeTicks() +
 970       base::TimeDelta::FromMilliseconds(animation_time_millis));
 971 }
 972
 973 jlong AwContents::ReleasePopupAwContents(JNIEnv* env, jobject obj) {
 974   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 975   return reinterpret_cast<intptr_t>(pending_contents_.release());
 976 }
 977
 978 gfx::Point AwContents::GetLocationOnScreen() {
 979   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 980   JNIEnv* env = AttachCurrentThread();
 981   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
 982   if (obj.is_null())
 983     return gfx::Point();
 984   std::vector<int> location;
 985   base::android::JavaIntArrayToIntVector(
 986       env,
 987       Java_AwContents_getLocationOnScreen(env, obj.obj()).obj(),
 988       &location);
 989   return gfx::Point(location[0], location[1]);
 990 }
 991
 992 void AwContents::ScrollContainerViewTo(gfx::Vector2d new_value) {
 993   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 994   JNIEnv* env = AttachCurrentThread();
 995   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
 996   if (obj.is_null())
 997     return;
 998   Java_AwContents_scrollContainerViewTo(
 999       env, obj.obj(), new_value.x(), new_value.y());
1000 }
1001
1002 bool AwContents::IsSmoothScrollingActive() const {
1003   DCHECK_CURRENTLY_ON(BrowserThread::UI);
1004   JNIEnv* env = AttachCurrentThread();
1005   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
1006   if (obj.is_null())
1007     return false;
1008   return Java_AwContents_isSmoothScrollingActive(env, obj.obj());
1009 }
1010
1011 void AwContents::UpdateScrollState(gfx::Vector2d max_scroll_offset,
1012                                    gfx::SizeF contents_size_dip,
1013                                    float page_scale_factor,
1014                                    float min_page_scale_factor,
1015                                    float max_page_scale_factor) {
1016   DCHECK_CURRENTLY_ON(BrowserThread::UI);
1017   JNIEnv* env = AttachCurrentThread();
1018   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
1019   if (obj.is_null())
1020     return;
1021   Java_AwContents_updateScrollState(env,
1022                                     obj.obj(),
1023                                     max_scroll_offset.x(),
1024                                     max_scroll_offset.y(),
1025                                     contents_size_dip.width(),
1026                                     contents_size_dip.height(),
1027                                     page_scale_factor,
1028                                     min_page_scale_factor,
1029                                     max_page_scale_factor);
1030 }
1031
1032 void AwContents::DidOverscroll(gfx::Vector2d overscroll_delta,
1033                                gfx::Vector2dF overscroll_velocity) {
1034   DCHECK_CURRENTLY_ON(BrowserThread::UI);
1035   JNIEnv* env = AttachCurrentThread();
1036   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
1037   if (obj.is_null())
1038     return;
1039   Java_AwContents_didOverscroll(env, obj.obj(), overscroll_delta.x(),
1040                                 overscroll_delta.y(), overscroll_velocity.x(),
1041                                 overscroll_velocity.y());
1042 }
1043
1044 void AwContents::SetDipScale(JNIEnv* env, jobject obj, jfloat dip_scale) {
1045   DCHECK_CURRENTLY_ON(BrowserThread::UI);
1046   SetDipScaleInternal(dip_scale);
1047 }
1048
1049 void AwContents::SetDipScaleInternal(float dip_scale) {
1050   browser_view_renderer_.SetDipScale(dip_scale);
1051 }
1052
1053 void AwContents::ScrollTo(JNIEnv* env, jobject obj, jint x, jint y) {
1054   DCHECK_CURRENTLY_ON(BrowserThread::UI);
1055   browser_view_renderer_.ScrollTo(gfx::Vector2d(x, y));
1056 }
1057
1058 void AwContents::OnWebLayoutPageScaleFactorChanged(float page_scale_factor) {
1059   DCHECK_CURRENTLY_ON(BrowserThread::UI);
1060   JNIEnv* env = AttachCurrentThread();
1061   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
1062   if (obj.is_null())
1063     return;
1064   Java_AwContents_onWebLayoutPageScaleFactorChanged(env, obj.obj(),
1065                                                          page_scale_factor);
1066 }
1067
1068 void AwContents::OnWebLayoutContentsSizeChanged(
1069     const gfx::Size& contents_size) {
1070   DCHECK_CURRENTLY_ON(BrowserThread::UI);
1071   JNIEnv* env = AttachCurrentThread();
1072   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
1073   if (obj.is_null())
1074     return;
1075   Java_AwContents_onWebLayoutContentsSizeChanged(
1076       env, obj.obj(), contents_size.width(), contents_size.height());
1077 }
1078
1079 jlong AwContents::CapturePicture(JNIEnv* env,
1080                                  jobject obj,
1081                                  int width,
1082                                  int height) {
1083   DCHECK_CURRENTLY_ON(BrowserThread::UI);
1084   return reinterpret_cast<intptr_t>(
1085       new AwPicture(browser_view_renderer_.CapturePicture(width, height)));
1086 }
1087
1088 void AwContents::EnableOnNewPicture(JNIEnv* env,
1089                                     jobject obj,
1090                                     jboolean enabled) {
1091   DCHECK_CURRENTLY_ON(BrowserThread::UI);
1092   browser_view_renderer_.EnableOnNewPicture(enabled);
1093 }
1094
1095 namespace {
1096 void InvokeVisualStateCallback(const JavaObjectWeakGlobalRef& java_ref,
1097                                long request_id,
1098                                ScopedJavaGlobalRef<jobject>* callback,
1099                                bool result) {
1100   JNIEnv* env = AttachCurrentThread();
1101   ScopedJavaLocalRef<jobject> obj = java_ref.get(env);
1102   if (obj.is_null())
1103      return;
1104   Java_AwContents_invokeVisualStateCallback(
1105       env, obj.obj(), callback->obj(), request_id);
1106 }
1107 }  // namespace
1108
1109 void AwContents::InsertVisualStateCallback(
1110     JNIEnv* env, jobject obj, long request_id, jobject callback) {
1111   DCHECK_CURRENTLY_ON(BrowserThread::UI);
1112   ScopedJavaGlobalRef<jobject>* j_callback = new ScopedJavaGlobalRef<jobject>();
1113   j_callback->Reset(env, callback);
1114   web_contents_->GetMainFrame()->InsertVisualStateCallback(
1115       base::Bind(&InvokeVisualStateCallback, java_ref_, request_id,
1116                  base::Owned(j_callback)));
1117 }
1118
1119 void AwContents::ClearView(JNIEnv* env, jobject obj) {
1120   DCHECK_CURRENTLY_ON(BrowserThread::UI);
1121   browser_view_renderer_.ClearView();
1122 }
1123
1124 void AwContents::SetExtraHeadersForUrl(JNIEnv* env, jobject obj,
1125                                        jstring url, jstring jextra_headers) {
1126   std::string extra_headers;
1127   if (jextra_headers)
1128     extra_headers = ConvertJavaStringToUTF8(env, jextra_headers);
1129   AwResourceContext* resource_context = static_cast<AwResourceContext*>(
1130       AwBrowserContext::FromWebContents(web_contents_.get())->
1131       GetResourceContext());
1132   resource_context->SetExtraHeaders(GURL(ConvertJavaStringToUTF8(env, url)),
1133                                     extra_headers);
1134 }
1135
1136 void AwContents::SetJsOnlineProperty(JNIEnv* env,
1137                                      jobject obj,
1138                                      jboolean network_up) {
1139   DCHECK_CURRENTLY_ON(BrowserThread::UI);
1140   render_view_host_ext_->SetJsOnlineProperty(network_up);
1141 }
1142
1143 void AwContents::TrimMemory(JNIEnv* env,
1144                             jobject obj,
1145                             jint level,
1146                             jboolean visible) {
1147   DCHECK_CURRENTLY_ON(BrowserThread::UI);
1148   browser_view_renderer_.TrimMemory(level, visible);
1149 }
1150
1151 // TODO(sgurun) add support for posting a frame whose name is known (only
1152 //               main frame is supported at this time, see crbug.com/389721)
1153 void AwContents::PostMessageToFrame(JNIEnv* env, jobject obj,
1154     jstring frame_name, jstring message, jstring target_origin,
1155     jintArray sent_ports) {
1156
1157   // Use an empty source origin for android webview.
1158   base::string16 source_origin;
1159   base::string16 j_target_origin(ConvertJavaStringToUTF16(env, target_origin));
1160   base::string16 j_message(ConvertJavaStringToUTF16(env, message));
1161   std::vector<int> j_ports;
1162
1163   if (sent_ports != nullptr) {
1164     base::android::JavaIntArrayToIntVector(env, sent_ports, &j_ports);
1165     BrowserThread::PostTask(
1166         BrowserThread::IO,
1167         FROM_HERE,
1168         base::Bind(&AwMessagePortServiceImpl::RemoveSentPorts,
1169                    base::Unretained(AwMessagePortServiceImpl::GetInstance()),
1170                    j_ports));
1171   }
1172   std::vector<content::TransferredMessagePort> ports(j_ports.size());
1173   for (size_t i = 0; i < j_ports.size(); ++i)
1174     ports[i].id = j_ports[i];
1175   content::MessagePortProvider::PostMessageToFrame(web_contents_.get(),
1176                                                    source_origin,
1177                                                    j_target_origin,
1178                                                    j_message,
1179                                                    ports);
1180 }
1181
1182 scoped_refptr<AwMessagePortMessageFilter>
1183 AwContents::GetMessagePortMessageFilter() {
1184   // Create a message port message filter if necessary
1185   if (message_port_message_filter_.get() == nullptr) {
1186     message_port_message_filter_ =
1187         new AwMessagePortMessageFilter(
1188             web_contents_->GetMainFrame()->GetRoutingID());
1189     web_contents_->GetRenderProcessHost()->AddFilter(
1190         message_port_message_filter_.get());
1191   }
1192   return message_port_message_filter_;
1193 }
1194
1195 void AwContents::CreateMessageChannel(JNIEnv* env, jobject obj,
1196     jobjectArray ports) {
1197
1198   AwMessagePortServiceImpl::GetInstance()->CreateMessageChannel(env, ports,
1199       GetMessagePortMessageFilter());
1200 }
1201
1202 void SetShouldDownloadFavicons(JNIEnv* env, jclass jclazz) {
1203   g_should_download_favicons = true;
1204 }
1205
1206 }  // namespace android_webview