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.
5 #include "android_webview/native/aw_contents.h"
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/gpu_memory_buffer_factory_impl.h"
15 #include "android_webview/browser/hardware_renderer.h"
16 #include "android_webview/browser/net_disk_cache_remover.h"
17 #include "android_webview/browser/renderer_host/aw_resource_dispatcher_host_delegate.h"
18 #include "android_webview/browser/scoped_app_gl_state_restore.h"
19 #include "android_webview/common/aw_hit_test_data.h"
20 #include "android_webview/common/devtools_instrumentation.h"
21 #include "android_webview/native/aw_autofill_client.h"
22 #include "android_webview/native/aw_browser_dependency_factory.h"
23 #include "android_webview/native/aw_contents_client_bridge.h"
24 #include "android_webview/native/aw_contents_io_thread_client_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/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/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/base/l10n/l10n_util_android.h"
67 #include "ui/gfx/android/java_bitmap.h"
68 #include "ui/gfx/image/image.h"
69 #include "ui/gfx/size.h"
71 struct AwDrawSWFunctionTable;
72 struct AwDrawGLFunctionTable;
74 using autofill::ContentAutofillDriver;
75 using autofill::AutofillManager;
76 using base::android::AttachCurrentThread;
77 using base::android::ConvertJavaStringToUTF16;
78 using base::android::ConvertJavaStringToUTF8;
79 using base::android::ConvertUTF16ToJavaString;
80 using base::android::ConvertUTF8ToJavaString;
81 using base::android::JavaRef;
82 using base::android::ScopedJavaGlobalRef;
83 using base::android::ScopedJavaLocalRef;
84 using data_reduction_proxy::DataReductionProxySettings;
85 using navigation_interception::InterceptNavigationDelegate;
86 using content::BrowserThread;
87 using content::ContentViewCore;
88 using content::WebContents;
91 static AwDrawGLFunction DrawGLFunction;
92 static void DrawGLFunction(long view_context,
93 AwDrawGLInfo* draw_info,
95 // |view_context| is the value that was returned from the java
96 // AwContents.onPrepareDrawGL; this cast must match the code there.
97 reinterpret_cast<android_webview::AwContents*>(view_context)
102 namespace android_webview {
106 bool g_should_download_favicons = false;
108 const void* kAwContentsUserDataKey = &kAwContentsUserDataKey;
110 class AwContentsUserData : public base::SupportsUserData::Data {
112 AwContentsUserData(AwContents* ptr) : contents_(ptr) {}
114 static AwContents* GetContents(WebContents* web_contents) {
117 AwContentsUserData* data = reinterpret_cast<AwContentsUserData*>(
118 web_contents->GetUserData(kAwContentsUserDataKey));
119 return data ? data->contents_ : NULL;
123 AwContents* contents_;
126 base::subtle::Atomic32 g_instance_count = 0;
128 void OnIoThreadClientReady(content::RenderFrameHost* rfh) {
129 int render_process_id = rfh->GetProcess()->GetID();
130 int render_frame_id = rfh->GetRoutingID();
131 AwResourceDispatcherHostDelegate::OnIoThreadClientReady(
132 render_process_id, render_frame_id);
138 AwContents* AwContents::FromWebContents(WebContents* web_contents) {
139 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
140 return AwContentsUserData::GetContents(web_contents);
144 AwContents* AwContents::FromID(int render_process_id, int render_view_id) {
145 const content::RenderViewHost* rvh =
146 content::RenderViewHost::FromID(render_process_id, render_view_id);
147 if (!rvh) return NULL;
148 content::WebContents* web_contents =
149 content::WebContents::FromRenderViewHost(rvh);
150 if (!web_contents) return NULL;
151 return FromWebContents(web_contents);
155 AwBrowserPermissionRequestDelegate* AwBrowserPermissionRequestDelegate::FromID(
156 int render_process_id, int render_view_id) {
157 AwContents* aw_contents = AwContents::FromID(render_process_id,
159 return implicit_cast<AwBrowserPermissionRequestDelegate*>(aw_contents);
162 AwContents::AwContents(scoped_ptr<WebContents> web_contents)
163 : web_contents_(web_contents.Pass()),
164 shared_renderer_state_(
165 BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
167 browser_view_renderer_(
169 &shared_renderer_state_,
171 BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI)),
172 renderer_manager_key_(GLViewRendererManager::GetInstance()->NullKey()) {
173 base::subtle::NoBarrier_AtomicIncrement(&g_instance_count, 1);
174 icon_helper_.reset(new IconHelper(web_contents_.get()));
175 icon_helper_->SetListener(this);
176 web_contents_->SetUserData(kAwContentsUserDataKey,
177 new AwContentsUserData(this));
178 render_view_host_ext_.reset(
179 new AwRenderViewHostExt(this, web_contents_.get()));
181 permission_request_handler_.reset(
182 new PermissionRequestHandler(this, web_contents_.get()));
184 AwAutofillClient* autofill_manager_delegate =
185 AwAutofillClient::FromWebContents(web_contents_.get());
186 InitDataReductionProxyIfNecessary();
187 if (autofill_manager_delegate)
188 InitAutofillIfNecessary(autofill_manager_delegate->GetSaveFormData());
191 void AwContents::SetJavaPeers(JNIEnv* env,
194 jobject web_contents_delegate,
195 jobject contents_client_bridge,
196 jobject io_thread_client,
197 jobject intercept_navigation_delegate) {
198 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
199 // The |aw_content| param is technically spurious as it duplicates |obj| but
200 // is passed over anyway to make the binding more explicit.
201 java_ref_ = JavaObjectWeakGlobalRef(env, aw_contents);
203 web_contents_delegate_.reset(
204 new AwWebContentsDelegate(env, web_contents_delegate));
205 web_contents_->SetDelegate(web_contents_delegate_.get());
207 contents_client_bridge_.reset(
208 new AwContentsClientBridge(env, contents_client_bridge));
209 AwContentsClientBridgeBase::Associate(web_contents_.get(),
210 contents_client_bridge_.get());
212 AwContentsIoThreadClientImpl::Associate(
213 web_contents_.get(), ScopedJavaLocalRef<jobject>(env, io_thread_client));
215 InterceptNavigationDelegate::Associate(
217 make_scoped_ptr(new InterceptNavigationDelegate(
218 env, intercept_navigation_delegate)));
220 // Finally, having setup the associations, release any deferred requests
221 web_contents_->ForEachFrame(base::Bind(&OnIoThreadClientReady));
224 void AwContents::SetSaveFormData(bool enabled) {
225 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
226 InitAutofillIfNecessary(enabled);
227 // We need to check for the existence, since autofill_manager_delegate
228 // may not be created when the setting is false.
229 if (ContentAutofillDriver::FromWebContents(web_contents_.get())) {
230 AwAutofillClient::FromWebContents(web_contents_.get())->
231 SetSaveFormData(enabled);
235 void AwContents::InitDataReductionProxyIfNecessary() {
236 AwBrowserContext* browser_context =
237 AwBrowserContext::FromWebContents(web_contents_.get());
238 browser_context->CreateUserPrefServiceIfNecessary();
241 void AwContents::InitAutofillIfNecessary(bool enabled) {
242 // Do not initialize if the feature is not enabled.
245 // Check if the autofill driver already exists.
246 content::WebContents* web_contents = web_contents_.get();
247 if (ContentAutofillDriver::FromWebContents(web_contents))
250 AwBrowserContext::FromWebContents(web_contents)->
251 CreateUserPrefServiceIfNecessary();
252 AwAutofillClient::CreateForWebContents(web_contents);
253 ContentAutofillDriver::CreateForWebContentsAndDelegate(
255 AwAutofillClient::FromWebContents(web_contents),
256 l10n_util::GetDefaultLocale(),
257 AutofillManager::DISABLE_AUTOFILL_DOWNLOAD_MANAGER);
260 void AwContents::SetAwAutofillClient(jobject client) {
261 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
262 JNIEnv* env = AttachCurrentThread();
263 ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
266 Java_AwContents_setAwAutofillClient(env, obj.obj(), client);
269 AwContents::~AwContents() {
270 DCHECK(AwContents::FromWebContents(web_contents_.get()) == this);
271 DCHECK(!hardware_renderer_.get());
272 web_contents_->RemoveUserData(kAwContentsUserDataKey);
273 if (find_helper_.get())
274 find_helper_->SetListener(NULL);
275 if (icon_helper_.get())
276 icon_helper_->SetListener(NULL);
277 base::subtle::NoBarrier_AtomicIncrement(&g_instance_count, -1);
278 // When the last WebView is destroyed free all discardable memory allocated by
279 // Chromium, because the app process may continue to run for a long time
280 // without ever using another WebView.
281 if (base::subtle::NoBarrier_Load(&g_instance_count) == 0) {
282 base::MemoryPressureListener::NotifyMemoryPressure(
283 base::MemoryPressureListener::MEMORY_PRESSURE_CRITICAL);
287 jlong AwContents::GetWebContents(JNIEnv* env, jobject obj) {
288 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
289 DCHECK(web_contents_);
290 return reinterpret_cast<intptr_t>(web_contents_.get());
293 void AwContents::Destroy(JNIEnv* env, jobject obj) {
296 // We clear the contents_client_bridge_ here so that we break the link with
297 // the java peer. This is important for the popup window case, where we are
298 // swapping AwContents out that share the same java AwContentsClientBridge.
300 contents_client_bridge_.reset();
302 // We do not delete AwContents immediately. Some applications try to delete
303 // Webview in ShouldOverrideUrlLoading callback, which is a sync IPC from
305 BrowserThread::DeleteSoon(BrowserThread::UI, FROM_HERE, this);
308 static jlong Init(JNIEnv* env, jclass, jobject browser_context) {
309 // TODO(joth): Use |browser_context| to get the native BrowserContext, rather
310 // than hard-code the default instance lookup here.
311 scoped_ptr<WebContents> web_contents(content::WebContents::Create(
312 content::WebContents::CreateParams(AwBrowserContext::GetDefault())));
313 // Return an 'uninitialized' instance; most work is deferred until the
314 // subsequent SetJavaPeers() call.
315 return reinterpret_cast<intptr_t>(new AwContents(web_contents.Pass()));
318 static void SetAwDrawSWFunctionTable(JNIEnv* env, jclass,
319 jlong function_table) {
320 JavaBrowserViewRendererHelper::SetAwDrawSWFunctionTable(
321 reinterpret_cast<AwDrawSWFunctionTable*>(function_table));
324 static void SetAwDrawGLFunctionTable(JNIEnv* env, jclass,
325 jlong function_table) {
326 GpuMemoryBufferFactoryImpl::SetAwDrawGLFunctionTable(
327 reinterpret_cast<AwDrawGLFunctionTable*>(function_table));
330 static jlong GetAwDrawGLFunction(JNIEnv* env, jclass) {
331 return reinterpret_cast<intptr_t>(&DrawGLFunction);
335 jint GetNativeInstanceCount(JNIEnv* env, jclass) {
336 return base::subtle::NoBarrier_Load(&g_instance_count);
339 jlong AwContents::GetAwDrawGLViewContext(JNIEnv* env, jobject obj) {
340 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
341 return reinterpret_cast<intptr_t>(this);
344 void AwContents::DrawGL(AwDrawGLInfo* draw_info) {
346 GLViewRendererManager* manager = GLViewRendererManager::GetInstance();
347 base::AutoLock lock(render_thread_lock_);
348 if (renderer_manager_key_ != manager->NullKey()) {
349 manager->DidDrawGL(renderer_manager_key_);
353 ScopedAppGLStateRestore state_restore(
354 draw_info->mode == AwDrawGLInfo::kModeDraw
355 ? ScopedAppGLStateRestore::MODE_DRAW
356 : ScopedAppGLStateRestore::MODE_RESOURCE_MANAGEMENT);
357 ScopedAllowGL allow_gl;
359 if (!shared_renderer_state_.IsHardwareAllowed()) {
360 hardware_renderer_.reset();
364 if (draw_info->mode != AwDrawGLInfo::kModeDraw)
367 if (!hardware_renderer_) {
368 hardware_renderer_.reset(new HardwareRenderer(&shared_renderer_state_));
371 hardware_renderer_->DrawGL(state_restore.stencil_enabled(),
372 state_restore.framebuffer_binding_ext(),
377 void DocumentHasImagesCallback(const ScopedJavaGlobalRef<jobject>& message,
379 Java_AwContents_onDocumentHasImagesResponse(AttachCurrentThread(),
385 void AwContents::DocumentHasImages(JNIEnv* env, jobject obj, jobject message) {
386 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
387 ScopedJavaGlobalRef<jobject> j_message;
388 j_message.Reset(env, message);
389 render_view_host_ext_->DocumentHasImages(
390 base::Bind(&DocumentHasImagesCallback, j_message));
394 void GenerateMHTMLCallback(ScopedJavaGlobalRef<jobject>* callback,
395 const base::FilePath& path, int64 size) {
396 JNIEnv* env = AttachCurrentThread();
397 // Android files are UTF8, so the path conversion below is safe.
398 Java_AwContents_generateMHTMLCallback(
400 ConvertUTF8ToJavaString(env, path.AsUTF8Unsafe()).obj(),
401 size, callback->obj());
405 void AwContents::GenerateMHTML(JNIEnv* env, jobject obj,
406 jstring jpath, jobject callback) {
407 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
408 ScopedJavaGlobalRef<jobject>* j_callback = new ScopedJavaGlobalRef<jobject>();
409 j_callback->Reset(env, callback);
410 base::FilePath target_path(ConvertJavaStringToUTF8(env, jpath));
411 web_contents_->GenerateMHTML(
413 base::Bind(&GenerateMHTMLCallback, base::Owned(j_callback), target_path));
416 void AwContents::CreatePdfExporter(JNIEnv* env,
418 jobject pdfExporter) {
420 new AwPdfExporter(env,
422 web_contents_.get()));
425 bool AwContents::OnReceivedHttpAuthRequest(const JavaRef<jobject>& handler,
426 const std::string& host,
427 const std::string& realm) {
428 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
429 JNIEnv* env = AttachCurrentThread();
430 ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
434 ScopedJavaLocalRef<jstring> jhost = ConvertUTF8ToJavaString(env, host);
435 ScopedJavaLocalRef<jstring> jrealm = ConvertUTF8ToJavaString(env, realm);
436 devtools_instrumentation::ScopedEmbedderCallbackTask embedder_callback(
437 "onReceivedHttpAuthRequest");
438 Java_AwContents_onReceivedHttpAuthRequest(env, obj.obj(), handler.obj(),
439 jhost.obj(), jrealm.obj());
443 void AwContents::AddVisitedLinks(JNIEnv* env,
445 jobjectArray jvisited_links) {
446 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
447 std::vector<base::string16> visited_link_strings;
448 base::android::AppendJavaStringArrayToStringVector(
449 env, jvisited_links, &visited_link_strings);
451 std::vector<GURL> visited_link_gurls;
452 std::vector<base::string16>::const_iterator itr;
453 for (itr = visited_link_strings.begin(); itr != visited_link_strings.end();
455 visited_link_gurls.push_back(GURL(*itr));
458 AwBrowserContext::FromWebContents(web_contents_.get())
459 ->AddVisitedURLs(visited_link_gurls);
462 bool RegisterAwContents(JNIEnv* env) {
463 return RegisterNativesImpl(env);
468 void ShowGeolocationPromptHelperTask(const JavaObjectWeakGlobalRef& java_ref,
469 const GURL& origin) {
470 JNIEnv* env = AttachCurrentThread();
471 ScopedJavaLocalRef<jobject> j_ref = java_ref.get(env);
473 ScopedJavaLocalRef<jstring> j_origin(
474 ConvertUTF8ToJavaString(env, origin.spec()));
475 devtools_instrumentation::ScopedEmbedderCallbackTask embedder_callback(
476 "onGeolocationPermissionsShowPrompt");
477 Java_AwContents_onGeolocationPermissionsShowPrompt(env,
483 void ShowGeolocationPromptHelper(const JavaObjectWeakGlobalRef& java_ref,
484 const GURL& origin) {
485 JNIEnv* env = AttachCurrentThread();
486 if (java_ref.get(env).obj()) {
487 content::BrowserThread::PostTask(
488 content::BrowserThread::UI,
490 base::Bind(&ShowGeolocationPromptHelperTask,
496 } // anonymous namespace
498 void AwContents::ShowGeolocationPrompt(const GURL& requesting_frame,
499 base::Callback<void(bool)> callback) {
500 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
502 GURL origin = requesting_frame.GetOrigin();
503 bool show_prompt = pending_geolocation_prompts_.empty();
504 pending_geolocation_prompts_.push_back(OriginCallback(origin, callback));
506 ShowGeolocationPromptHelper(java_ref_, origin);
511 void AwContents::InvokeGeolocationCallback(JNIEnv* env,
515 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
517 GURL callback_origin(base::android::ConvertJavaStringToUTF16(env, origin));
518 if (callback_origin.GetOrigin() ==
519 pending_geolocation_prompts_.front().first) {
520 pending_geolocation_prompts_.front().second.Run(value);
521 pending_geolocation_prompts_.pop_front();
522 if (!pending_geolocation_prompts_.empty()) {
523 ShowGeolocationPromptHelper(java_ref_,
524 pending_geolocation_prompts_.front().first);
529 void AwContents::HideGeolocationPrompt(const GURL& origin) {
530 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
531 bool removed_current_outstanding_callback = false;
532 std::list<OriginCallback>::iterator it = pending_geolocation_prompts_.begin();
533 while (it != pending_geolocation_prompts_.end()) {
534 if ((*it).first == origin.GetOrigin()) {
535 if (it == pending_geolocation_prompts_.begin()) {
536 removed_current_outstanding_callback = true;
538 it = pending_geolocation_prompts_.erase(it);
544 if (removed_current_outstanding_callback) {
545 JNIEnv* env = AttachCurrentThread();
546 ScopedJavaLocalRef<jobject> j_ref = java_ref_.get(env);
548 devtools_instrumentation::ScopedEmbedderCallbackTask embedder_callback(
549 "onGeolocationPermissionsHidePrompt");
550 Java_AwContents_onGeolocationPermissionsHidePrompt(env, j_ref.obj());
552 if (!pending_geolocation_prompts_.empty()) {
553 ShowGeolocationPromptHelper(java_ref_,
554 pending_geolocation_prompts_.front().first);
559 void AwContents::OnPermissionRequest(AwPermissionRequest* request) {
560 JNIEnv* env = AttachCurrentThread();
561 ScopedJavaLocalRef<jobject> j_request = request->CreateJavaPeer();
562 ScopedJavaLocalRef<jobject> j_ref = java_ref_.get(env);
563 if (j_request.is_null() || j_ref.is_null()) {
564 permission_request_handler_->CancelRequest(
565 request->GetOrigin(), request->GetResources());
569 Java_AwContents_onPermissionRequest(env, j_ref.obj(), j_request.obj());
572 void AwContents::OnPermissionRequestCanceled(AwPermissionRequest* request) {
573 JNIEnv* env = AttachCurrentThread();
574 ScopedJavaLocalRef<jobject> j_request = request->GetJavaObject();
575 ScopedJavaLocalRef<jobject> j_ref = java_ref_.get(env);
576 if (j_request.is_null() || j_ref.is_null())
579 Java_AwContents_onPermissionRequestCanceled(
580 env, j_ref.obj(), j_request.obj());
583 void AwContents::PreauthorizePermission(
588 permission_request_handler_->PreauthorizePermission(
589 GURL(base::android::ConvertJavaStringToUTF8(env, origin)), resources);
592 void AwContents::RequestProtectedMediaIdentifierPermission(
594 const base::Callback<void(bool)>& callback) {
595 permission_request_handler_->SendRequest(
596 scoped_ptr<AwPermissionRequestDelegate>(new SimplePermissionRequest(
597 origin, AwPermissionRequest::ProtectedMediaId, callback)));
600 void AwContents::CancelProtectedMediaIdentifierPermissionRequests(
601 const GURL& origin) {
602 permission_request_handler_->CancelRequest(
603 origin, AwPermissionRequest::ProtectedMediaId);
606 void AwContents::RequestGeolocationPermission(
608 const base::Callback<void(bool)>& callback) {
609 JNIEnv* env = AttachCurrentThread();
610 ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
614 if (Java_AwContents_useLegacyGeolocationPermissionAPI(env, obj.obj())) {
615 ShowGeolocationPrompt(origin, callback);
618 permission_request_handler_->SendRequest(
619 scoped_ptr<AwPermissionRequestDelegate>(new SimplePermissionRequest(
620 origin, AwPermissionRequest::Geolocation, callback)));
623 void AwContents::CancelGeolocationPermissionRequests(const GURL& origin) {
624 JNIEnv* env = AttachCurrentThread();
625 ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
629 if (Java_AwContents_useLegacyGeolocationPermissionAPI(env, obj.obj())) {
630 HideGeolocationPrompt(origin);
633 permission_request_handler_->CancelRequest(
634 origin, AwPermissionRequest::Geolocation);
637 void AwContents::FindAllAsync(JNIEnv* env, jobject obj, jstring search_string) {
638 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
639 GetFindHelper()->FindAllAsync(ConvertJavaStringToUTF16(env, search_string));
642 void AwContents::FindNext(JNIEnv* env, jobject obj, jboolean forward) {
643 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
644 GetFindHelper()->FindNext(forward);
647 void AwContents::ClearMatches(JNIEnv* env, jobject obj) {
648 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
649 GetFindHelper()->ClearMatches();
652 void AwContents::ClearCache(
655 jboolean include_disk_files) {
656 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
657 render_view_host_ext_->ClearCache();
659 if (include_disk_files) {
660 RemoveHttpDiskCache(web_contents_->GetBrowserContext(),
661 web_contents_->GetRoutingID());
665 FindHelper* AwContents::GetFindHelper() {
666 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
667 if (!find_helper_.get()) {
668 find_helper_.reset(new FindHelper(web_contents_.get()));
669 find_helper_->SetListener(this);
671 return find_helper_.get();
674 void AwContents::OnFindResultReceived(int active_ordinal,
677 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
678 JNIEnv* env = AttachCurrentThread();
679 ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
683 Java_AwContents_onFindResultReceived(
684 env, obj.obj(), active_ordinal, match_count, finished);
687 bool AwContents::ShouldDownloadFavicon(const GURL& icon_url) {
688 return g_should_download_favicons;
691 void AwContents::OnReceivedIcon(const GURL& icon_url, const SkBitmap& bitmap) {
692 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
693 JNIEnv* env = AttachCurrentThread();
694 ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
698 content::NavigationEntry* entry =
699 web_contents_->GetController().GetActiveEntry();
702 entry->GetFavicon().valid = true;
703 entry->GetFavicon().url = icon_url;
704 entry->GetFavicon().image = gfx::Image::CreateFrom1xBitmap(bitmap);
707 Java_AwContents_onReceivedIcon(
708 env, obj.obj(), gfx::ConvertToJavaBitmap(&bitmap).obj());
711 void AwContents::OnReceivedTouchIconUrl(const std::string& url,
713 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
714 JNIEnv* env = AttachCurrentThread();
715 ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
719 Java_AwContents_onReceivedTouchIconUrl(
720 env, obj.obj(), ConvertUTF8ToJavaString(env, url).obj(), precomposed);
723 bool AwContents::RequestDrawGL(jobject canvas, bool wait_for_completion) {
724 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
725 DCHECK(!canvas || !wait_for_completion);
726 JNIEnv* env = AttachCurrentThread();
727 ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
730 return Java_AwContents_requestDrawGL(
731 env, obj.obj(), canvas, wait_for_completion);
734 void AwContents::PostInvalidate() {
735 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
736 JNIEnv* env = AttachCurrentThread();
737 ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
739 Java_AwContents_postInvalidateOnAnimation(env, obj.obj());
742 void AwContents::OnNewPicture() {
743 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
744 JNIEnv* env = AttachCurrentThread();
745 ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
746 if (!obj.is_null()) {
747 devtools_instrumentation::ScopedEmbedderCallbackTask embedder_callback(
749 Java_AwContents_onNewPicture(env, obj.obj());
753 base::android::ScopedJavaLocalRef<jbyteArray>
754 AwContents::GetCertificate(JNIEnv* env,
756 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
757 content::NavigationEntry* entry =
758 web_contents_->GetController().GetActiveEntry();
760 return ScopedJavaLocalRef<jbyteArray>();
761 // Get the certificate
762 int cert_id = entry->GetSSL().cert_id;
763 scoped_refptr<net::X509Certificate> cert;
764 bool ok = content::CertStore::GetInstance()->RetrieveCert(cert_id, &cert);
766 return ScopedJavaLocalRef<jbyteArray>();
768 // Convert the certificate and return it
769 std::string der_string;
770 net::X509Certificate::GetDEREncoded(cert->os_cert_handle(), &der_string);
771 return base::android::ToJavaByteArray(env,
772 reinterpret_cast<const uint8*>(der_string.data()), der_string.length());
775 void AwContents::RequestNewHitTestDataAt(JNIEnv* env, jobject obj,
777 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
778 render_view_host_ext_->RequestNewHitTestDataAt(x, y);
781 void AwContents::UpdateLastHitTestData(JNIEnv* env, jobject obj) {
782 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
783 if (!render_view_host_ext_->HasNewHitTestData()) return;
785 const AwHitTestData& data = render_view_host_ext_->GetLastHitTestData();
786 render_view_host_ext_->MarkHitTestDataRead();
788 // Make sure to null the Java object if data is empty/invalid.
789 ScopedJavaLocalRef<jstring> extra_data_for_type;
790 if (data.extra_data_for_type.length())
791 extra_data_for_type = ConvertUTF8ToJavaString(
792 env, data.extra_data_for_type);
794 ScopedJavaLocalRef<jstring> href;
795 if (data.href.length())
796 href = ConvertUTF16ToJavaString(env, data.href);
798 ScopedJavaLocalRef<jstring> anchor_text;
799 if (data.anchor_text.length())
800 anchor_text = ConvertUTF16ToJavaString(env, data.anchor_text);
802 ScopedJavaLocalRef<jstring> img_src;
803 if (data.img_src.is_valid())
804 img_src = ConvertUTF8ToJavaString(env, data.img_src.spec());
806 Java_AwContents_updateHitTestData(env,
809 extra_data_for_type.obj(),
815 void AwContents::OnSizeChanged(JNIEnv* env, jobject obj,
816 int w, int h, int ow, int oh) {
817 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
818 browser_view_renderer_.OnSizeChanged(w, h);
821 void AwContents::SetViewVisibility(JNIEnv* env, jobject obj, bool visible) {
822 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
823 browser_view_renderer_.SetViewVisibility(visible);
826 void AwContents::SetWindowVisibility(JNIEnv* env, jobject obj, bool visible) {
827 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
828 browser_view_renderer_.SetWindowVisibility(visible);
831 void AwContents::SetIsPaused(JNIEnv* env, jobject obj, bool paused) {
832 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
833 browser_view_renderer_.SetIsPaused(paused);
834 ContentViewCore* cvc =
835 ContentViewCore::FromWebContents(web_contents_.get());
837 cvc->PauseOrResumeGeolocation(paused);
844 void AwContents::OnAttachedToWindow(JNIEnv* env, jobject obj, int w, int h) {
845 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
846 shared_renderer_state_.SetHardwareAllowed(true);
847 browser_view_renderer_.OnAttachedToWindow(w, h);
850 void AwContents::InitializeHardwareDrawIfNeeded() {
851 GLViewRendererManager* manager = GLViewRendererManager::GetInstance();
853 base::AutoLock lock(render_thread_lock_);
854 if (renderer_manager_key_ == manager->NullKey()) {
855 renderer_manager_key_ = manager->PushBack(&shared_renderer_state_);
856 DeferredGpuCommandService::SetInstance();
860 void AwContents::OnDetachedFromWindow(JNIEnv* env, jobject obj) {
861 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
862 shared_renderer_state_.SetHardwareAllowed(false);
864 bool hardware_initialized = browser_view_renderer_.hardware_enabled();
865 if (hardware_initialized) {
866 bool draw_functor_succeeded = RequestDrawGL(NULL, true);
867 if (!draw_functor_succeeded) {
868 LOG(ERROR) << "Unable to free GL resources. Has the Window leaked?";
869 // Calling release on wrong thread intentionally.
871 info.mode = AwDrawGLInfo::kModeProcess;
876 DCHECK(!hardware_renderer_);
877 browser_view_renderer_.OnDetachedFromWindow();
879 GLViewRendererManager* manager = GLViewRendererManager::GetInstance();
882 base::AutoLock lock(render_thread_lock_);
883 if (renderer_manager_key_ != manager->NullKey()) {
884 manager->Remove(renderer_manager_key_);
885 renderer_manager_key_ = manager->NullKey();
889 if (hardware_initialized) {
890 // Flush any invoke functors that's caused by OnDetachedFromWindow.
891 RequestDrawGL(NULL, true);
895 base::android::ScopedJavaLocalRef<jbyteArray>
896 AwContents::GetOpaqueState(JNIEnv* env, jobject obj) {
897 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
898 // Required optimization in WebViewClassic to not save any state if
899 // there has been no navigations.
900 if (!web_contents_->GetController().GetEntryCount())
901 return ScopedJavaLocalRef<jbyteArray>();
904 if (!WriteToPickle(*web_contents_, &pickle)) {
905 return ScopedJavaLocalRef<jbyteArray>();
907 return base::android::ToJavaByteArray(env,
908 reinterpret_cast<const uint8*>(pickle.data()), pickle.size());
912 jboolean AwContents::RestoreFromOpaqueState(
913 JNIEnv* env, jobject obj, jbyteArray state) {
914 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
915 // TODO(boliu): This copy can be optimized out if this is a performance
917 std::vector<uint8> state_vector;
918 base::android::JavaByteArrayToByteVector(env, state, &state_vector);
920 Pickle pickle(reinterpret_cast<const char*>(state_vector.begin()),
921 state_vector.size());
922 PickleIterator iterator(pickle);
924 return RestoreFromPickle(&iterator, web_contents_.get());
927 bool AwContents::OnDraw(JNIEnv* env,
930 jboolean is_hardware_accelerated,
941 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
942 if (is_hardware_accelerated)
943 InitializeHardwareDrawIfNeeded();
944 return browser_view_renderer_.OnDraw(
946 is_hardware_accelerated,
947 gfx::Vector2d(scroll_x, scroll_y),
948 gfx::Rect(visible_left,
950 visible_right - visible_left,
951 visible_bottom - visible_top),
953 clip_left, clip_top, clip_right - clip_left, clip_bottom - clip_top));
956 void AwContents::SetPendingWebContentsForPopup(
957 scoped_ptr<content::WebContents> pending) {
958 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
959 if (pending_contents_.get()) {
960 // TODO(benm): Support holding multiple pop up window requests.
961 LOG(WARNING) << "Blocking popup window creation as an outstanding "
962 << "popup window is still pending.";
963 base::MessageLoop::current()->DeleteSoon(FROM_HERE, pending.release());
966 pending_contents_.reset(new AwContents(pending.Pass()));
969 void AwContents::FocusFirstNode(JNIEnv* env, jobject obj) {
970 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
971 web_contents_->FocusThroughTabTraversal(false);
974 void AwContents::SetBackgroundColor(JNIEnv* env, jobject obj, jint color) {
975 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
976 render_view_host_ext_->SetBackgroundColor(color);
979 jlong AwContents::ReleasePopupAwContents(JNIEnv* env, jobject obj) {
980 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
981 return reinterpret_cast<intptr_t>(pending_contents_.release());
984 gfx::Point AwContents::GetLocationOnScreen() {
985 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
986 JNIEnv* env = AttachCurrentThread();
987 ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
990 std::vector<int> location;
991 base::android::JavaIntArrayToIntVector(
993 Java_AwContents_getLocationOnScreen(env, obj.obj()).obj(),
995 return gfx::Point(location[0], location[1]);
998 void AwContents::ScrollContainerViewTo(gfx::Vector2d new_value) {
999 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1000 JNIEnv* env = AttachCurrentThread();
1001 ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
1004 Java_AwContents_scrollContainerViewTo(
1005 env, obj.obj(), new_value.x(), new_value.y());
1008 bool AwContents::IsFlingActive() const {
1009 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1010 JNIEnv* env = AttachCurrentThread();
1011 ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
1014 return Java_AwContents_isFlingActive(env, obj.obj());
1017 void AwContents::UpdateScrollState(gfx::Vector2d max_scroll_offset,
1018 gfx::SizeF contents_size_dip,
1019 float page_scale_factor,
1020 float min_page_scale_factor,
1021 float max_page_scale_factor) {
1022 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1023 JNIEnv* env = AttachCurrentThread();
1024 ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
1027 Java_AwContents_updateScrollState(env,
1029 max_scroll_offset.x(),
1030 max_scroll_offset.y(),
1031 contents_size_dip.width(),
1032 contents_size_dip.height(),
1034 min_page_scale_factor,
1035 max_page_scale_factor);
1038 void AwContents::DidOverscroll(gfx::Vector2d overscroll_delta) {
1039 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1040 JNIEnv* env = AttachCurrentThread();
1041 ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
1044 Java_AwContents_didOverscroll(
1045 env, obj.obj(), overscroll_delta.x(), overscroll_delta.y());
1048 const BrowserViewRenderer* AwContents::GetBrowserViewRenderer() const {
1049 return &browser_view_renderer_;
1052 void AwContents::SetDipScale(JNIEnv* env, jobject obj, jfloat dip_scale) {
1053 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1054 browser_view_renderer_.SetDipScale(dip_scale);
1057 void AwContents::SetFixedLayoutSize(JNIEnv* env,
1061 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1062 render_view_host_ext_->SetFixedLayoutSize(gfx::Size(width_dip, height_dip));
1065 void AwContents::ScrollTo(JNIEnv* env, jobject obj, jint x, jint y) {
1066 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1067 browser_view_renderer_.ScrollTo(gfx::Vector2d(x, y));
1070 void AwContents::OnWebLayoutPageScaleFactorChanged(float page_scale_factor) {
1071 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1072 JNIEnv* env = AttachCurrentThread();
1073 ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
1076 Java_AwContents_onWebLayoutPageScaleFactorChanged(env, obj.obj(),
1080 void AwContents::OnWebLayoutContentsSizeChanged(
1081 const gfx::Size& contents_size) {
1082 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1083 JNIEnv* env = AttachCurrentThread();
1084 ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
1087 Java_AwContents_onWebLayoutContentsSizeChanged(
1088 env, obj.obj(), contents_size.width(), contents_size.height());
1091 jlong AwContents::CapturePicture(JNIEnv* env,
1095 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1096 return reinterpret_cast<intptr_t>(
1097 new AwPicture(browser_view_renderer_.CapturePicture(width, height)));
1100 void AwContents::EnableOnNewPicture(JNIEnv* env,
1103 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1104 browser_view_renderer_.EnableOnNewPicture(enabled);
1107 void AwContents::ClearView(JNIEnv* env, jobject obj) {
1108 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1109 browser_view_renderer_.ClearView();
1112 void AwContents::SetExtraHeadersForUrl(JNIEnv* env, jobject obj,
1113 jstring url, jstring jextra_headers) {
1114 std::string extra_headers;
1116 extra_headers = ConvertJavaStringToUTF8(env, jextra_headers);
1117 AwResourceContext* resource_context = static_cast<AwResourceContext*>(
1118 AwBrowserContext::FromWebContents(web_contents_.get())->
1119 GetResourceContext());
1120 resource_context->SetExtraHeaders(GURL(ConvertJavaStringToUTF8(env, url)),
1124 void AwContents::SendCheckRenderThreadResponsiveness(JNIEnv* env, jobject obj) {
1125 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1126 render_view_host_ext_->SendCheckRenderThreadResponsiveness();
1129 void AwContents::SetJsOnlineProperty(JNIEnv* env,
1131 jboolean network_up) {
1132 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1133 render_view_host_ext_->SetJsOnlineProperty(network_up);
1136 void AwContents::TrimMemory(JNIEnv* env,
1140 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1141 browser_view_renderer_.TrimMemory(level, visible);
1144 void SetShouldDownloadFavicons(JNIEnv* env, jclass jclazz) {
1145 g_should_download_favicons = true;
1148 } // namespace android_webview