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