aw_contents.cc 59 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602
  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. #include "android_webview/browser/aw_contents.h"
  5. #include <limits>
  6. #include <memory>
  7. #include <string>
  8. #include <utility>
  9. #include "android_webview/browser/aw_autofill_client.h"
  10. #include "android_webview/browser/aw_browser_context.h"
  11. #include "android_webview/browser/aw_browser_main_parts.h"
  12. #include "android_webview/browser/aw_contents_client_bridge.h"
  13. #include "android_webview/browser/aw_contents_io_thread_client.h"
  14. #include "android_webview/browser/aw_pdf_exporter.h"
  15. #include "android_webview/browser/aw_render_process.h"
  16. #include "android_webview/browser/aw_renderer_priority.h"
  17. #include "android_webview/browser/aw_resource_context.h"
  18. #include "android_webview/browser/aw_settings.h"
  19. #include "android_webview/browser/aw_web_contents_delegate.h"
  20. #include "android_webview/browser/gfx/aw_gl_functor.h"
  21. #include "android_webview/browser/gfx/aw_picture.h"
  22. #include "android_webview/browser/gfx/browser_view_renderer.h"
  23. #include "android_webview/browser/gfx/child_frame.h"
  24. #include "android_webview/browser/gfx/gpu_service_webview.h"
  25. #include "android_webview/browser/gfx/java_browser_view_renderer_helper.h"
  26. #include "android_webview/browser/gfx/render_thread_manager.h"
  27. #include "android_webview/browser/gfx/scoped_app_gl_state_restore.h"
  28. #include "android_webview/browser/js_java_interaction/aw_web_message_host_factory.h"
  29. #include "android_webview/browser/lifecycle/aw_contents_lifecycle_notifier.h"
  30. #include "android_webview/browser/page_load_metrics/page_load_metrics_initialize.h"
  31. #include "android_webview/browser/permission/aw_permission_request.h"
  32. #include "android_webview/browser/permission/permission_request_handler.h"
  33. #include "android_webview/browser/permission/simple_permission_request.h"
  34. #include "android_webview/browser/state_serializer.h"
  35. #include "android_webview/browser_jni_headers/AwContents_jni.h"
  36. #include "android_webview/common/aw_switches.h"
  37. #include "android_webview/common/devtools_instrumentation.h"
  38. #include "android_webview/common/mojom/frame.mojom.h"
  39. #include "base/android/jni_android.h"
  40. #include "base/android/jni_array.h"
  41. #include "base/android/jni_string.h"
  42. #include "base/android/locale_utils.h"
  43. #include "base/android/scoped_java_ref.h"
  44. #include "base/atomicops.h"
  45. #include "base/bind.h"
  46. #include "base/callback.h"
  47. #include "base/callback_helpers.h"
  48. #include "base/command_line.h"
  49. #include "base/feature_list.h"
  50. #include "base/i18n/rtl.h"
  51. #include "base/json/json_writer.h"
  52. #include "base/location.h"
  53. #include "base/memory/memory_pressure_listener.h"
  54. #include "base/memory/raw_ptr.h"
  55. #include "base/no_destructor.h"
  56. #include "base/pickle.h"
  57. #include "base/supports_user_data.h"
  58. #include "base/task/single_thread_task_runner.h"
  59. #include "base/threading/thread_restrictions.h"
  60. #include "base/threading/thread_task_runner_handle.h"
  61. #include "components/android_autofill/browser/android_autofill_manager.h"
  62. #include "components/android_autofill/browser/autofill_provider_android.h"
  63. #include "components/autofill/content/browser/content_autofill_driver_factory.h"
  64. #include "components/autofill/core/browser/webdata/autofill_webdata_service.h"
  65. #include "components/autofill/core/common/autofill_features.h"
  66. #include "components/navigation_interception/intercept_navigation_delegate.h"
  67. #include "components/safe_browsing/core/common/features.h"
  68. #include "components/security_interstitials/content/security_interstitial_tab_helper.h"
  69. #include "components/viz/common/surfaces/frame_sink_id.h"
  70. #include "content/public/browser/android/child_process_importance.h"
  71. #include "content/public/browser/android/synchronous_compositor.h"
  72. #include "content/public/browser/browser_task_traits.h"
  73. #include "content/public/browser/browser_thread.h"
  74. #include "content/public/browser/browsing_data_remover.h"
  75. #include "content/public/browser/child_process_security_policy.h"
  76. #include "content/public/browser/favicon_status.h"
  77. #include "content/public/browser/navigation_entry.h"
  78. #include "content/public/browser/navigation_handle.h"
  79. #include "content/public/browser/page.h"
  80. #include "content/public/browser/render_frame_host.h"
  81. #include "content/public/browser/render_process_host.h"
  82. #include "content/public/browser/render_view_host.h"
  83. #include "content/public/browser/render_widget_host.h"
  84. #include "content/public/browser/render_widget_host_iterator.h"
  85. #include "content/public/browser/ssl_status.h"
  86. #include "content/public/browser/web_contents.h"
  87. #include "content/public/common/mhtml_generation_params.h"
  88. #include "net/base/auth.h"
  89. #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
  90. #include "net/cert/x509_certificate.h"
  91. #include "net/cert/x509_util.h"
  92. #include "third_party/skia/include/core/SkPicture.h"
  93. #include "ui/gfx/android/java_bitmap.h"
  94. #include "ui/gfx/geometry/rect_f.h"
  95. #include "ui/gfx/geometry/size.h"
  96. #include "ui/gfx/image/image.h"
  97. #include "url/origin.h"
  98. #include "url/url_constants.h"
  99. struct AwDrawSWFunctionTable;
  100. using autofill::ContentAutofillDriverFactory;
  101. using base::android::AttachCurrentThread;
  102. using base::android::ConvertJavaStringToUTF16;
  103. using base::android::ConvertJavaStringToUTF8;
  104. using base::android::ConvertUTF16ToJavaString;
  105. using base::android::ConvertUTF8ToJavaString;
  106. using base::android::HasException;
  107. using base::android::JavaParamRef;
  108. using base::android::JavaRef;
  109. using base::android::ScopedJavaGlobalRef;
  110. using base::android::ScopedJavaLocalRef;
  111. using content::BrowserThread;
  112. using content::RenderFrameHost;
  113. using content::WebContents;
  114. using js_injection::JsCommunicationHost;
  115. using navigation_interception::InterceptNavigationDelegate;
  116. namespace android_webview {
  117. class CompositorFrameConsumer;
  118. namespace {
  119. bool g_should_download_favicons = false;
  120. std::string* g_locale() {
  121. static base::NoDestructor<std::string> locale;
  122. return locale.get();
  123. }
  124. std::string* g_locale_list() {
  125. static base::NoDestructor<std::string> locale_list;
  126. return locale_list.get();
  127. }
  128. const void* const kAwContentsUserDataKey = &kAwContentsUserDataKey;
  129. const void* const kComputedRendererPriorityUserDataKey =
  130. &kComputedRendererPriorityUserDataKey;
  131. class AwContentsUserData : public base::SupportsUserData::Data {
  132. public:
  133. explicit AwContentsUserData(AwContents* ptr) : contents_(ptr) {}
  134. static AwContents* GetContents(WebContents* web_contents) {
  135. if (!web_contents)
  136. return NULL;
  137. AwContentsUserData* data = static_cast<AwContentsUserData*>(
  138. web_contents->GetUserData(kAwContentsUserDataKey));
  139. return data ? data->contents_.get() : NULL;
  140. }
  141. private:
  142. raw_ptr<AwContents> contents_;
  143. };
  144. base::subtle::Atomic32 g_instance_count = 0;
  145. } // namespace
  146. class ScopedAllowInitGLBindings {
  147. public:
  148. ScopedAllowInitGLBindings() {}
  149. ~ScopedAllowInitGLBindings() {}
  150. private:
  151. base::ScopedAllowBlocking allow_blocking_;
  152. };
  153. // static
  154. AwContents* AwContents::FromWebContents(WebContents* web_contents) {
  155. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  156. return AwContentsUserData::GetContents(web_contents);
  157. }
  158. // static
  159. void JNI_AwContents_UpdateDefaultLocale(
  160. JNIEnv* env,
  161. const JavaParamRef<jstring>& locale,
  162. const JavaParamRef<jstring>& locale_list) {
  163. *g_locale() = ConvertJavaStringToUTF8(env, locale);
  164. *g_locale_list() = ConvertJavaStringToUTF8(env, locale_list);
  165. }
  166. // static
  167. std::string AwContents::GetLocale() {
  168. return *g_locale();
  169. }
  170. // static
  171. std::string AwContents::GetLocaleList() {
  172. return *g_locale_list();
  173. }
  174. // static
  175. AwBrowserPermissionRequestDelegate* AwBrowserPermissionRequestDelegate::FromID(
  176. int render_process_id,
  177. int render_frame_id) {
  178. AwContents* aw_contents =
  179. AwContents::FromWebContents(content::WebContents::FromRenderFrameHost(
  180. content::RenderFrameHost::FromID(render_process_id,
  181. render_frame_id)));
  182. return aw_contents;
  183. }
  184. // static
  185. AwSafeBrowsingUIManager::UIManagerClient*
  186. AwSafeBrowsingUIManager::UIManagerClient::FromWebContents(
  187. WebContents* web_contents) {
  188. return AwContents::FromWebContents(web_contents);
  189. }
  190. // static
  191. AwRenderProcessGoneDelegate* AwRenderProcessGoneDelegate::FromWebContents(
  192. content::WebContents* web_contents) {
  193. return AwContents::FromWebContents(web_contents);
  194. }
  195. AwContents::AwContents(std::unique_ptr<WebContents> web_contents)
  196. : content::WebContentsObserver(web_contents.get()),
  197. browser_view_renderer_(this, content::GetUIThreadTaskRunner({})),
  198. web_contents_(std::move(web_contents)) {
  199. base::subtle::NoBarrier_AtomicIncrement(&g_instance_count, 1);
  200. icon_helper_ = std::make_unique<IconHelper>(web_contents_.get());
  201. icon_helper_->SetListener(this);
  202. web_contents_->SetUserData(android_webview::kAwContentsUserDataKey,
  203. std::make_unique<AwContentsUserData>(this));
  204. browser_view_renderer_.RegisterWithWebContents(web_contents_.get());
  205. viz::FrameSinkId frame_sink_id;
  206. if (web_contents_->GetRenderViewHost()) {
  207. frame_sink_id =
  208. web_contents_->GetRenderViewHost()->GetWidget()->GetFrameSinkId();
  209. }
  210. browser_view_renderer_.SetActiveFrameSinkId(frame_sink_id);
  211. render_view_host_ext_ =
  212. std::make_unique<AwRenderViewHostExt>(this, web_contents_.get());
  213. InitializePageLoadMetricsForWebContents(web_contents_.get());
  214. permission_request_handler_ =
  215. std::make_unique<PermissionRequestHandler>(this, web_contents_.get());
  216. AwAutofillClient* browser_autofill_manager_delegate =
  217. AwAutofillClient::FromWebContents(web_contents_.get());
  218. if (browser_autofill_manager_delegate) {
  219. InitAutofillIfNecessary(
  220. browser_autofill_manager_delegate->GetSaveFormData());
  221. }
  222. content::SynchronousCompositor::SetClientForWebContents(
  223. web_contents_.get(), &browser_view_renderer_);
  224. AwContentsLifecycleNotifier::GetInstance().OnWebViewCreated(this);
  225. AwBrowserProcess::GetInstance()->visibility_metrics_logger()->AddClient(this);
  226. }
  227. void AwContents::SetJavaPeers(
  228. JNIEnv* env,
  229. const JavaParamRef<jobject>& aw_contents,
  230. const JavaParamRef<jobject>& web_contents_delegate,
  231. const JavaParamRef<jobject>& contents_client_bridge,
  232. const JavaParamRef<jobject>& io_thread_client,
  233. const JavaParamRef<jobject>& intercept_navigation_delegate) {
  234. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  235. // The |aw_content| param is technically spurious as it duplicates |obj| but
  236. // is passed over anyway to make the binding more explicit.
  237. java_ref_ = JavaObjectWeakGlobalRef(env, aw_contents);
  238. web_contents_delegate_ =
  239. std::make_unique<AwWebContentsDelegate>(env, web_contents_delegate);
  240. web_contents_->SetDelegate(web_contents_delegate_.get());
  241. contents_client_bridge_ =
  242. std::make_unique<AwContentsClientBridge>(env, contents_client_bridge);
  243. AwContentsClientBridge::Associate(web_contents_.get(),
  244. contents_client_bridge_.get());
  245. AwContentsIoThreadClient::Associate(web_contents_.get(), io_thread_client);
  246. InterceptNavigationDelegate::Associate(
  247. web_contents_.get(), std::make_unique<InterceptNavigationDelegate>(
  248. env, intercept_navigation_delegate));
  249. }
  250. void AwContents::InitializeAndroidAutofill(JNIEnv* env) {
  251. // Initialize Android Autofill, this method shall only be called in Android O
  252. // and beyond.
  253. // AutofillProvider shall already be created for |web_contents_| from
  254. // AutofillProvider java.
  255. DCHECK(autofill::AutofillProvider::FromWebContents(web_contents_.get()));
  256. // Autocomplete is only supported for Android pre-O, disable it if Android
  257. // autofill is enabled.
  258. InitAutofillIfNecessary(/*autocomplete_enabled=*/false);
  259. }
  260. void AwContents::SetSaveFormData(bool enabled) {
  261. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  262. InitAutofillIfNecessary(enabled);
  263. // We need to check for the existence, since browser_autofill_manager_delegate
  264. // may not be created when the setting is false.
  265. if (AwAutofillClient::FromWebContents(web_contents_.get())) {
  266. AwAutofillClient::FromWebContents(web_contents_.get())
  267. ->SetSaveFormData(enabled);
  268. }
  269. }
  270. void AwContents::InitAutofillIfNecessary(bool autocomplete_enabled) {
  271. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  272. // This method initializes either Android autofill or Chrome autocomplete:
  273. // - If autofill_provider is available, Android autofill shall be initialized.
  274. // - Otherwise, initialize Chrome autocomplete if autocomplete_enabled.
  275. // Check if the autofill driver factory already exists.
  276. content::WebContents* web_contents = web_contents_.get();
  277. if (ContentAutofillDriverFactory::FromWebContents(web_contents))
  278. return;
  279. // The autofill_provider object shall already be created by the
  280. // AutofillProvider Java object in Android O and beyond.
  281. auto* autofill_provider =
  282. autofill::AutofillProvider::FromWebContents(web_contents);
  283. // Just return, if the app neither runs on O sdk nor enables autocomplete.
  284. if (!autofill_provider && !autocomplete_enabled)
  285. return;
  286. autofill::AutofillManager::EnableDownloadManager enable_download_manager(
  287. !autofill::AutofillProvider::is_download_manager_disabled_for_testing());
  288. AwAutofillClient::CreateForWebContents(web_contents);
  289. // WebView browser tests may shall use BrowserAutofillManager if
  290. // `!autofill_provider`.
  291. ContentAutofillDriverFactory::DriverInitCallback driver_init_hook =
  292. autofill_provider
  293. ? base::BindRepeating(&autofill::AndroidDriverInitHook,
  294. AwAutofillClient::FromWebContents(web_contents),
  295. enable_download_manager)
  296. : base::BindRepeating(&autofill::BrowserDriverInitHook,
  297. AwAutofillClient::FromWebContents(web_contents),
  298. base::android::GetDefaultLocaleString());
  299. ContentAutofillDriverFactory::CreateForWebContentsAndDelegate(
  300. web_contents, AwAutofillClient::FromWebContents(web_contents),
  301. std::move(driver_init_hook));
  302. }
  303. void AwContents::SetAwAutofillClient(const JavaRef<jobject>& client) {
  304. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  305. JNIEnv* env = AttachCurrentThread();
  306. ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
  307. if (!obj)
  308. return;
  309. Java_AwContents_setAwAutofillClient(env, obj, client);
  310. }
  311. AwContents::~AwContents() {
  312. DCHECK_EQ(this, AwContents::FromWebContents(web_contents_.get()));
  313. web_contents_->RemoveUserData(kAwContentsUserDataKey);
  314. AwContentsClientBridge::Dissociate(web_contents_.get());
  315. if (find_helper_.get())
  316. find_helper_->SetListener(NULL);
  317. if (icon_helper_.get())
  318. icon_helper_->SetListener(NULL);
  319. base::subtle::Atomic32 instance_count =
  320. base::subtle::NoBarrier_AtomicIncrement(&g_instance_count, -1);
  321. // When the last WebView is destroyed free all discardable memory allocated by
  322. // Chromium, because the app process may continue to run for a long time
  323. // without ever using another WebView.
  324. if (instance_count == 0) {
  325. // TODO(timvolodine): consider moving NotifyMemoryPressure to
  326. // AwContentsLifecycleNotifier (crbug.com/522988).
  327. base::MemoryPressureListener::NotifyMemoryPressure(
  328. base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL);
  329. }
  330. browser_view_renderer_.SetCurrentCompositorFrameConsumer(nullptr);
  331. AwContentsLifecycleNotifier::GetInstance().OnWebViewDestroyed(this);
  332. WebContentsObserver::Observe(nullptr);
  333. AwBrowserProcess::GetInstance()->visibility_metrics_logger()->RemoveClient(
  334. this);
  335. }
  336. base::android::ScopedJavaLocalRef<jobject> AwContents::GetWebContents(
  337. JNIEnv* env) {
  338. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  339. DCHECK(web_contents_);
  340. if (!web_contents_)
  341. return base::android::ScopedJavaLocalRef<jobject>();
  342. return web_contents_->GetJavaWebContents();
  343. }
  344. base::android::ScopedJavaLocalRef<jobject> AwContents::GetBrowserContext(
  345. JNIEnv* env) {
  346. if (!web_contents_)
  347. return base::android::ScopedJavaLocalRef<jobject>();
  348. return AwBrowserContext::FromWebContents(web_contents_.get())
  349. ->GetJavaBrowserContext();
  350. }
  351. void AwContents::SetCompositorFrameConsumer(JNIEnv* env,
  352. jlong compositor_frame_consumer) {
  353. browser_view_renderer_.SetCurrentCompositorFrameConsumer(
  354. reinterpret_cast<CompositorFrameConsumer*>(compositor_frame_consumer));
  355. }
  356. ScopedJavaLocalRef<jobject> AwContents::GetRenderProcess(JNIEnv* env) {
  357. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  358. content::RenderProcessHost* host =
  359. web_contents_->GetPrimaryMainFrame()->GetProcess();
  360. if (host->run_renderer_in_process()) {
  361. return ScopedJavaLocalRef<jobject>();
  362. }
  363. AwRenderProcess* render_process =
  364. AwRenderProcess::GetInstanceForRenderProcessHost(host);
  365. return render_process->GetJavaObject();
  366. }
  367. void AwContents::Destroy(JNIEnv* env) {
  368. java_ref_.reset();
  369. delete this;
  370. }
  371. static jlong JNI_AwContents_Init(JNIEnv* env, jlong browser_context_pointer) {
  372. AwBrowserContext* browser_context =
  373. reinterpret_cast<AwBrowserContext*>(browser_context_pointer);
  374. std::unique_ptr<WebContents> web_contents(content::WebContents::Create(
  375. content::WebContents::CreateParams(browser_context)));
  376. // Return an 'uninitialized' instance; most work is deferred until the
  377. // subsequent SetJavaPeers() call.
  378. return reinterpret_cast<intptr_t>(new AwContents(std::move(web_contents)));
  379. }
  380. static jboolean JNI_AwContents_HasRequiredHardwareExtensions(JNIEnv* env) {
  381. ScopedAllowInitGLBindings scoped_allow_init_gl_bindings;
  382. // Make sure GPUInfo is collected. This will initialize GL bindings,
  383. // collect GPUInfo, and compute GpuFeatureInfo if they have not been
  384. // already done.
  385. return GpuServiceWebView::GetInstance()
  386. ->gpu_info()
  387. .can_support_threaded_texture_mailbox;
  388. }
  389. static void JNI_AwContents_SetAwDrawSWFunctionTable(JNIEnv* env,
  390. jlong function_table) {
  391. RasterHelperSetAwDrawSWFunctionTable(
  392. reinterpret_cast<AwDrawSWFunctionTable*>(function_table));
  393. }
  394. static void JNI_AwContents_SetAwDrawGLFunctionTable(JNIEnv* env,
  395. jlong function_table) {}
  396. static void JNI_AwContents_UpdateScreenCoverage(
  397. JNIEnv* env,
  398. jint global_percentage,
  399. const base::android::JavaParamRef<jobjectArray>& jschemes,
  400. const base::android::JavaParamRef<jintArray>& jscheme_percentages) {
  401. std::vector<std::string> schemes;
  402. AppendJavaStringArrayToStringVector(env, jschemes, &schemes);
  403. std::vector<int> scheme_percentages;
  404. JavaIntArrayToIntVector(env, jscheme_percentages, &scheme_percentages);
  405. DCHECK(schemes.size() == scheme_percentages.size());
  406. std::vector<VisibilityMetricsLogger::Scheme> scheme_enums(schemes.size());
  407. for (size_t i = 0; i < schemes.size(); i++) {
  408. scheme_enums[i] = VisibilityMetricsLogger::SchemeStringToEnum(schemes[i]);
  409. }
  410. AwBrowserProcess::GetInstance()
  411. ->visibility_metrics_logger()
  412. ->UpdateScreenCoverage(global_percentage, scheme_enums,
  413. scheme_percentages);
  414. }
  415. // static
  416. jint JNI_AwContents_GetNativeInstanceCount(JNIEnv* env) {
  417. return base::subtle::NoBarrier_Load(&g_instance_count);
  418. }
  419. // static
  420. ScopedJavaLocalRef<jstring> JNI_AwContents_GetSafeBrowsingLocaleForTesting(
  421. JNIEnv* env) {
  422. ScopedJavaLocalRef<jstring> locale =
  423. ConvertUTF8ToJavaString(env, base::i18n::GetConfiguredLocale());
  424. return locale;
  425. }
  426. namespace {
  427. void DocumentHasImagesCallback(const ScopedJavaGlobalRef<jobject>& message,
  428. bool has_images) {
  429. Java_AwContents_onDocumentHasImagesResponse(AttachCurrentThread(), has_images,
  430. message);
  431. }
  432. } // namespace
  433. void AwContents::DocumentHasImages(JNIEnv* env,
  434. const JavaParamRef<jobject>& message) {
  435. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  436. ScopedJavaGlobalRef<jobject> j_message;
  437. j_message.Reset(env, message);
  438. render_view_host_ext_->DocumentHasImages(
  439. base::BindOnce(&DocumentHasImagesCallback, j_message));
  440. }
  441. namespace {
  442. void GenerateMHTMLCallback(const JavaRef<jobject>& callback,
  443. const base::FilePath& path,
  444. int64_t size) {
  445. JNIEnv* env = AttachCurrentThread();
  446. // Android files are UTF8, so the path conversion below is safe.
  447. Java_AwContents_generateMHTMLCallback(
  448. env, ConvertUTF8ToJavaString(env, path.AsUTF8Unsafe()), size, callback);
  449. }
  450. } // namespace
  451. void AwContents::GenerateMHTML(JNIEnv* env,
  452. const JavaParamRef<jstring>& jpath,
  453. const JavaParamRef<jobject>& callback) {
  454. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  455. base::FilePath target_path(ConvertJavaStringToUTF8(env, jpath));
  456. web_contents_->GenerateMHTML(
  457. content::MHTMLGenerationParams(target_path),
  458. base::BindOnce(&GenerateMHTMLCallback,
  459. ScopedJavaGlobalRef<jobject>(env, callback), target_path));
  460. }
  461. void AwContents::CreatePdfExporter(JNIEnv* env,
  462. const JavaParamRef<jobject>& pdfExporter) {
  463. pdf_exporter_ =
  464. std::make_unique<AwPdfExporter>(env, pdfExporter, web_contents_.get());
  465. }
  466. bool AwContents::OnReceivedHttpAuthRequest(const JavaRef<jobject>& handler,
  467. const std::string& host,
  468. const std::string& realm) {
  469. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  470. JNIEnv* env = AttachCurrentThread();
  471. ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
  472. if (!obj)
  473. return false;
  474. ScopedJavaLocalRef<jstring> jhost = ConvertUTF8ToJavaString(env, host);
  475. ScopedJavaLocalRef<jstring> jrealm = ConvertUTF8ToJavaString(env, realm);
  476. devtools_instrumentation::ScopedEmbedderCallbackTask embedder_callback(
  477. "onReceivedHttpAuthRequest");
  478. Java_AwContents_onReceivedHttpAuthRequest(env, obj, handler, jhost, jrealm);
  479. return true;
  480. }
  481. void AwContents::SetOffscreenPreRaster(bool enabled) {
  482. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  483. browser_view_renderer_.SetOffscreenPreRaster(enabled);
  484. }
  485. void AwContents::AddVisitedLinks(
  486. JNIEnv* env,
  487. const JavaParamRef<jobjectArray>& jvisited_links) {
  488. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  489. std::vector<std::u16string> visited_link_strings;
  490. base::android::AppendJavaStringArrayToStringVector(env, jvisited_links,
  491. &visited_link_strings);
  492. std::vector<GURL> visited_link_gurls;
  493. std::vector<std::u16string>::const_iterator itr;
  494. for (itr = visited_link_strings.begin(); itr != visited_link_strings.end();
  495. ++itr) {
  496. visited_link_gurls.push_back(GURL(*itr));
  497. }
  498. AwBrowserContext::FromWebContents(web_contents_.get())
  499. ->AddVisitedURLs(visited_link_gurls);
  500. }
  501. namespace {
  502. void ShowGeolocationPromptHelperTask(const JavaObjectWeakGlobalRef& java_ref,
  503. const GURL& origin) {
  504. JNIEnv* env = AttachCurrentThread();
  505. ScopedJavaLocalRef<jobject> j_ref = java_ref.get(env);
  506. if (j_ref.obj()) {
  507. ScopedJavaLocalRef<jstring> j_origin(
  508. ConvertUTF8ToJavaString(env, origin.spec()));
  509. devtools_instrumentation::ScopedEmbedderCallbackTask embedder_callback(
  510. "onGeolocationPermissionsShowPrompt");
  511. Java_AwContents_onGeolocationPermissionsShowPrompt(env, j_ref, j_origin);
  512. }
  513. }
  514. void ShowGeolocationPromptHelper(const JavaObjectWeakGlobalRef& java_ref,
  515. const GURL& origin) {
  516. JNIEnv* env = AttachCurrentThread();
  517. if (java_ref.get(env).obj()) {
  518. content::GetUIThreadTaskRunner({})->PostTask(
  519. FROM_HERE,
  520. base::BindOnce(&ShowGeolocationPromptHelperTask, java_ref, origin));
  521. }
  522. }
  523. } // anonymous namespace
  524. void AwContents::ShowGeolocationPrompt(const GURL& requesting_frame,
  525. PermissionCallback callback) {
  526. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  527. GURL origin = requesting_frame.DeprecatedGetOriginAsURL();
  528. bool show_prompt = pending_geolocation_prompts_.empty();
  529. pending_geolocation_prompts_.emplace_back(origin, std::move(callback));
  530. if (show_prompt) {
  531. ShowGeolocationPromptHelper(java_ref_, origin);
  532. }
  533. }
  534. // Invoked from Java
  535. void AwContents::InvokeGeolocationCallback(
  536. JNIEnv* env,
  537. jboolean value,
  538. const JavaParamRef<jstring>& origin) {
  539. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  540. if (pending_geolocation_prompts_.empty())
  541. return;
  542. GURL callback_origin(base::android::ConvertJavaStringToUTF16(env, origin));
  543. if (callback_origin.DeprecatedGetOriginAsURL() ==
  544. pending_geolocation_prompts_.front().first) {
  545. std::move(pending_geolocation_prompts_.front().second).Run(value);
  546. pending_geolocation_prompts_.pop_front();
  547. if (!pending_geolocation_prompts_.empty()) {
  548. ShowGeolocationPromptHelper(java_ref_,
  549. pending_geolocation_prompts_.front().first);
  550. }
  551. }
  552. }
  553. void AwContents::HideGeolocationPrompt(const GURL& origin) {
  554. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  555. bool removed_current_outstanding_callback = false;
  556. std::list<OriginCallback>::iterator it = pending_geolocation_prompts_.begin();
  557. while (it != pending_geolocation_prompts_.end()) {
  558. if ((*it).first == origin.DeprecatedGetOriginAsURL()) {
  559. if (it == pending_geolocation_prompts_.begin()) {
  560. removed_current_outstanding_callback = true;
  561. }
  562. it = pending_geolocation_prompts_.erase(it);
  563. } else {
  564. ++it;
  565. }
  566. }
  567. if (removed_current_outstanding_callback) {
  568. JNIEnv* env = AttachCurrentThread();
  569. ScopedJavaLocalRef<jobject> j_ref = java_ref_.get(env);
  570. if (j_ref.obj()) {
  571. devtools_instrumentation::ScopedEmbedderCallbackTask embedder_callback(
  572. "onGeolocationPermissionsHidePrompt");
  573. Java_AwContents_onGeolocationPermissionsHidePrompt(env, j_ref);
  574. }
  575. if (!pending_geolocation_prompts_.empty()) {
  576. ShowGeolocationPromptHelper(java_ref_,
  577. pending_geolocation_prompts_.front().first);
  578. }
  579. }
  580. }
  581. void AwContents::OnPermissionRequest(
  582. base::android::ScopedJavaLocalRef<jobject> j_request,
  583. AwPermissionRequest* request) {
  584. DCHECK(j_request);
  585. DCHECK(request);
  586. JNIEnv* env = AttachCurrentThread();
  587. ScopedJavaLocalRef<jobject> j_ref = java_ref_.get(env);
  588. if (!j_ref) {
  589. permission_request_handler_->CancelRequest(request->GetOrigin(),
  590. request->GetResources());
  591. return;
  592. }
  593. Java_AwContents_onPermissionRequest(env, j_ref, j_request);
  594. }
  595. void AwContents::OnPermissionRequestCanceled(AwPermissionRequest* request) {
  596. JNIEnv* env = AttachCurrentThread();
  597. ScopedJavaLocalRef<jobject> j_request = request->GetJavaObject();
  598. ScopedJavaLocalRef<jobject> j_ref = java_ref_.get(env);
  599. if (!j_request || !j_ref)
  600. return;
  601. Java_AwContents_onPermissionRequestCanceled(env, j_ref, j_request);
  602. }
  603. void AwContents::PreauthorizePermission(JNIEnv* env,
  604. const JavaParamRef<jstring>& origin,
  605. jlong resources) {
  606. permission_request_handler_->PreauthorizePermission(
  607. GURL(base::android::ConvertJavaStringToUTF8(env, origin)), resources);
  608. }
  609. void AwContents::RequestProtectedMediaIdentifierPermission(
  610. const GURL& origin,
  611. PermissionCallback callback) {
  612. permission_request_handler_->SendRequest(
  613. std::make_unique<SimplePermissionRequest>(
  614. origin, AwPermissionRequest::ProtectedMediaId, std::move(callback)));
  615. }
  616. void AwContents::CancelProtectedMediaIdentifierPermissionRequests(
  617. const GURL& origin) {
  618. permission_request_handler_->CancelRequest(
  619. origin, AwPermissionRequest::ProtectedMediaId);
  620. }
  621. void AwContents::RequestGeolocationPermission(const GURL& origin,
  622. PermissionCallback callback) {
  623. JNIEnv* env = AttachCurrentThread();
  624. ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
  625. if (!obj)
  626. return;
  627. if (Java_AwContents_useLegacyGeolocationPermissionAPI(env, obj)) {
  628. ShowGeolocationPrompt(origin, std::move(callback));
  629. return;
  630. }
  631. permission_request_handler_->SendRequest(
  632. std::make_unique<SimplePermissionRequest>(
  633. origin, AwPermissionRequest::Geolocation, std::move(callback)));
  634. }
  635. void AwContents::CancelGeolocationPermissionRequests(const GURL& origin) {
  636. JNIEnv* env = AttachCurrentThread();
  637. ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
  638. if (!obj)
  639. return;
  640. if (Java_AwContents_useLegacyGeolocationPermissionAPI(env, obj)) {
  641. HideGeolocationPrompt(origin);
  642. return;
  643. }
  644. permission_request_handler_->CancelRequest(origin,
  645. AwPermissionRequest::Geolocation);
  646. }
  647. void AwContents::RequestMIDISysexPermission(const GURL& origin,
  648. PermissionCallback callback) {
  649. permission_request_handler_->SendRequest(
  650. std::make_unique<SimplePermissionRequest>(
  651. origin, AwPermissionRequest::MIDISysex, std::move(callback)));
  652. }
  653. void AwContents::CancelMIDISysexPermissionRequests(const GURL& origin) {
  654. permission_request_handler_->CancelRequest(
  655. origin, AwPermissionRequest::AwPermissionRequest::MIDISysex);
  656. }
  657. void AwContents::FindAllAsync(JNIEnv* env,
  658. const JavaParamRef<jstring>& search_string) {
  659. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  660. GetFindHelper()->FindAllAsync(ConvertJavaStringToUTF16(env, search_string));
  661. }
  662. void AwContents::FindNext(JNIEnv* env, jboolean forward) {
  663. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  664. GetFindHelper()->FindNext(forward);
  665. }
  666. void AwContents::ClearMatches(JNIEnv* env) {
  667. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  668. GetFindHelper()->ClearMatches();
  669. }
  670. void AwContents::ClearCache(JNIEnv* env, jboolean include_disk_files) {
  671. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  672. AwRenderProcess* aw_render_process =
  673. AwRenderProcess::GetInstanceForRenderProcessHost(
  674. web_contents_->GetPrimaryMainFrame()->GetProcess());
  675. aw_render_process->ClearCache();
  676. if (include_disk_files) {
  677. content::BrowsingDataRemover* remover =
  678. web_contents_->GetBrowserContext()->GetBrowsingDataRemover();
  679. remover->Remove(
  680. base::Time(), base::Time::Max(),
  681. content::BrowsingDataRemover::DATA_TYPE_CACHE,
  682. content::BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB |
  683. content::BrowsingDataRemover::ORIGIN_TYPE_PROTECTED_WEB);
  684. }
  685. }
  686. FindHelper* AwContents::GetFindHelper() {
  687. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  688. if (!find_helper_.get()) {
  689. find_helper_ = std::make_unique<FindHelper>(web_contents_.get());
  690. find_helper_->SetListener(this);
  691. }
  692. return find_helper_.get();
  693. }
  694. bool AwContents::AllowThirdPartyCookies() {
  695. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  696. AwSettings* aw_settings = AwSettings::FromWebContents(web_contents_.get());
  697. return aw_settings->GetAllowThirdPartyCookies();
  698. }
  699. void AwContents::OnFindResultReceived(int active_ordinal,
  700. int match_count,
  701. bool finished) {
  702. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  703. JNIEnv* env = AttachCurrentThread();
  704. ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
  705. if (!obj)
  706. return;
  707. Java_AwContents_onFindResultReceived(env, obj, active_ordinal, match_count,
  708. finished);
  709. }
  710. bool AwContents::ShouldDownloadFavicon(const GURL& icon_url) {
  711. return g_should_download_favicons;
  712. }
  713. void AwContents::OnReceivedIcon(const GURL& icon_url, const SkBitmap& bitmap) {
  714. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  715. JNIEnv* env = AttachCurrentThread();
  716. ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
  717. if (!obj)
  718. return;
  719. content::NavigationEntry* entry =
  720. web_contents_->GetController().GetLastCommittedEntry();
  721. if (entry) {
  722. entry->GetFavicon().valid = true;
  723. entry->GetFavicon().url = icon_url;
  724. entry->GetFavicon().image = gfx::Image::CreateFrom1xBitmap(bitmap);
  725. }
  726. ScopedJavaLocalRef<jobject> java_bitmap =
  727. gfx::ConvertToJavaBitmap(bitmap, gfx::OomBehavior::kReturnNullOnOom);
  728. if (!java_bitmap) {
  729. LOG(WARNING) << "Skipping onReceivedIcon; Not enough memory to convert "
  730. "icon to Bitmap.";
  731. return;
  732. }
  733. Java_AwContents_onReceivedIcon(env, obj, java_bitmap);
  734. }
  735. void AwContents::OnReceivedTouchIconUrl(const std::string& url,
  736. bool precomposed) {
  737. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  738. JNIEnv* env = AttachCurrentThread();
  739. ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
  740. if (!obj)
  741. return;
  742. Java_AwContents_onReceivedTouchIconUrl(
  743. env, obj, ConvertUTF8ToJavaString(env, url), precomposed);
  744. }
  745. void AwContents::PostInvalidate(bool inside_vsync) {
  746. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  747. JNIEnv* env = AttachCurrentThread();
  748. ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
  749. if (obj)
  750. Java_AwContents_postInvalidate(env, obj, inside_vsync);
  751. }
  752. void AwContents::OnNewPicture() {
  753. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  754. JNIEnv* env = AttachCurrentThread();
  755. ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
  756. if (obj) {
  757. devtools_instrumentation::ScopedEmbedderCallbackTask embedder_callback(
  758. "onNewPicture");
  759. Java_AwContents_onNewPicture(env, obj);
  760. }
  761. }
  762. void AwContents::OnViewTreeForceDarkStateChanged(
  763. bool view_tree_force_dark_state) {
  764. view_tree_force_dark_state_ = view_tree_force_dark_state;
  765. web_contents_->NotifyPreferencesChanged();
  766. }
  767. base::android::ScopedJavaLocalRef<jbyteArray> AwContents::GetCertificate(
  768. JNIEnv* env) {
  769. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  770. content::NavigationEntry* entry =
  771. web_contents_->GetController().GetLastCommittedEntry();
  772. if (!entry || entry->IsInitialEntry() || !entry->GetSSL().certificate) {
  773. return ScopedJavaLocalRef<jbyteArray>();
  774. }
  775. // Convert the certificate and return it
  776. base::StringPiece der_string = net::x509_util::CryptoBufferAsStringPiece(
  777. entry->GetSSL().certificate->cert_buffer());
  778. return base::android::ToJavaByteArray(
  779. env, reinterpret_cast<const uint8_t*>(der_string.data()),
  780. der_string.length());
  781. }
  782. void AwContents::RequestNewHitTestDataAt(JNIEnv* env,
  783. jfloat x,
  784. jfloat y,
  785. jfloat touch_major) {
  786. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  787. gfx::PointF touch_center(x, y);
  788. gfx::SizeF touch_area(touch_major, touch_major);
  789. render_view_host_ext_->RequestNewHitTestDataAt(touch_center, touch_area);
  790. }
  791. void AwContents::UpdateLastHitTestData(JNIEnv* env) {
  792. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  793. ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
  794. if (!obj)
  795. return;
  796. android_webview::mojom::HitTestDataPtr data =
  797. render_view_host_ext_->TakeLastHitTestData();
  798. if (!data)
  799. return;
  800. // Make sure to null the Java object if data is empty/invalid.
  801. ScopedJavaLocalRef<jstring> extra_data_for_type;
  802. if (data->extra_data_for_type.length())
  803. extra_data_for_type =
  804. ConvertUTF8ToJavaString(env, data->extra_data_for_type);
  805. ScopedJavaLocalRef<jstring> href;
  806. if (data->href.length())
  807. href = ConvertUTF16ToJavaString(env, data->href);
  808. ScopedJavaLocalRef<jstring> anchor_text;
  809. if (data->anchor_text.length())
  810. anchor_text = ConvertUTF16ToJavaString(env, data->anchor_text);
  811. ScopedJavaLocalRef<jstring> img_src;
  812. if (data->img_src.is_valid())
  813. img_src = ConvertUTF8ToJavaString(env, data->img_src.spec());
  814. Java_AwContents_updateHitTestData(env, obj, static_cast<jint>(data->type),
  815. extra_data_for_type, href, anchor_text,
  816. img_src);
  817. }
  818. void AwContents::OnSizeChanged(JNIEnv* env, int w, int h, int ow, int oh) {
  819. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  820. gfx::Size size(w, h);
  821. web_contents_->GetNativeView()->OnPhysicalBackingSizeChanged(size);
  822. web_contents_->GetNativeView()->OnSizeChanged(w, h);
  823. browser_view_renderer_.OnSizeChanged(w, h);
  824. AwBrowserProcess::GetInstance()
  825. ->visibility_metrics_logger()
  826. ->ClientVisibilityChanged(this);
  827. }
  828. void AwContents::OnConfigurationChanged(JNIEnv* env) {
  829. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  830. web_contents()->OnWebPreferencesChanged();
  831. }
  832. void AwContents::SetViewVisibility(JNIEnv* env, bool visible) {
  833. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  834. browser_view_renderer_.SetViewVisibility(visible);
  835. AwBrowserProcess::GetInstance()
  836. ->visibility_metrics_logger()
  837. ->ClientVisibilityChanged(this);
  838. }
  839. void AwContents::SetWindowVisibility(JNIEnv* env, bool visible) {
  840. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  841. browser_view_renderer_.SetWindowVisibility(visible);
  842. if (visible)
  843. AwContentsLifecycleNotifier::GetInstance().OnWebViewWindowBeVisible(this);
  844. else
  845. AwContentsLifecycleNotifier::GetInstance().OnWebViewWindowBeInvisible(this);
  846. AwBrowserProcess::GetInstance()
  847. ->visibility_metrics_logger()
  848. ->ClientVisibilityChanged(this);
  849. }
  850. void AwContents::SetIsPaused(JNIEnv* env, bool paused) {
  851. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  852. browser_view_renderer_.SetIsPaused(paused);
  853. }
  854. void AwContents::OnAttachedToWindow(JNIEnv* env, int w, int h) {
  855. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  856. browser_view_renderer_.OnAttachedToWindow(w, h);
  857. AwContentsLifecycleNotifier::GetInstance().OnWebViewAttachedToWindow(this);
  858. AwBrowserProcess::GetInstance()
  859. ->visibility_metrics_logger()
  860. ->ClientVisibilityChanged(this);
  861. }
  862. void AwContents::OnDetachedFromWindow(JNIEnv* env) {
  863. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  864. browser_view_renderer_.OnDetachedFromWindow();
  865. AwContentsLifecycleNotifier::GetInstance().OnWebViewDetachedFromWindow(this);
  866. AwBrowserProcess::GetInstance()
  867. ->visibility_metrics_logger()
  868. ->ClientVisibilityChanged(this);
  869. }
  870. bool AwContents::IsVisible(JNIEnv* env) {
  871. return browser_view_renderer_.IsClientVisible();
  872. }
  873. bool AwContents::IsDisplayingInterstitialForTesting(JNIEnv* env) {
  874. security_interstitials::SecurityInterstitialTabHelper*
  875. security_interstitial_tab_helper = security_interstitials::
  876. SecurityInterstitialTabHelper::FromWebContents(web_contents_.get());
  877. return security_interstitial_tab_helper &&
  878. security_interstitial_tab_helper->IsDisplayingInterstitial();
  879. }
  880. base::android::ScopedJavaLocalRef<jbyteArray> AwContents::GetOpaqueState(
  881. JNIEnv* env) {
  882. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  883. // Required optimization in WebViewClassic to not save any state if
  884. // there has been no navigations.
  885. if (!web_contents_->GetController().GetLastCommittedEntry() ||
  886. web_contents_->GetController()
  887. .GetLastCommittedEntry()
  888. ->IsInitialEntry()) {
  889. return ScopedJavaLocalRef<jbyteArray>();
  890. }
  891. base::Pickle pickle;
  892. WriteToPickle(*web_contents_, &pickle);
  893. return base::android::ToJavaByteArray(
  894. env, reinterpret_cast<const uint8_t*>(pickle.data()), pickle.size());
  895. }
  896. jboolean AwContents::RestoreFromOpaqueState(
  897. JNIEnv* env,
  898. const JavaParamRef<jbyteArray>& state) {
  899. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  900. // TODO(boliu): This copy can be optimized out if this is a performance
  901. // problem.
  902. std::vector<uint8_t> state_vector;
  903. base::android::JavaByteArrayToByteVector(env, state, &state_vector);
  904. base::Pickle pickle(reinterpret_cast<const char*>(state_vector.data()),
  905. state_vector.size());
  906. base::PickleIterator iterator(pickle);
  907. return RestoreFromPickle(&iterator, web_contents_.get());
  908. }
  909. bool AwContents::OnDraw(JNIEnv* env,
  910. const JavaParamRef<jobject>& canvas,
  911. jboolean is_hardware_accelerated,
  912. jint scroll_x,
  913. jint scroll_y,
  914. jint visible_left,
  915. jint visible_top,
  916. jint visible_right,
  917. jint visible_bottom,
  918. jboolean force_auxiliary_bitmap_rendering) {
  919. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  920. gfx::Point scroll(scroll_x, scroll_y);
  921. browser_view_renderer_.PrepareToDraw(
  922. scroll, gfx::Rect(visible_left, visible_top, visible_right - visible_left,
  923. visible_bottom - visible_top));
  924. if (is_hardware_accelerated && browser_view_renderer_.attached_to_window() &&
  925. !force_auxiliary_bitmap_rendering) {
  926. return browser_view_renderer_.OnDrawHardware();
  927. }
  928. gfx::Size view_size = browser_view_renderer_.size();
  929. if (view_size.IsEmpty()) {
  930. TRACE_EVENT_INSTANT0("android_webview", "EarlyOut_EmptySize",
  931. TRACE_EVENT_SCOPE_THREAD);
  932. return false;
  933. }
  934. // TODO(hush): Right now webview size is passed in as the auxiliary bitmap
  935. // size, which might hurt performance (only for software draws with auxiliary
  936. // bitmap). For better performance, get global visible rect, transform it
  937. // from screen space to view space, then intersect with the webview in
  938. // viewspace. Use the resulting rect as the auxiliary bitmap.
  939. std::unique_ptr<SoftwareCanvasHolder> canvas_holder =
  940. SoftwareCanvasHolder::Create(canvas, scroll, view_size,
  941. force_auxiliary_bitmap_rendering);
  942. if (!canvas_holder || !canvas_holder->GetCanvas()) {
  943. TRACE_EVENT_INSTANT0("android_webview", "EarlyOut_NoSoftwareCanvas",
  944. TRACE_EVENT_SCOPE_THREAD);
  945. return false;
  946. }
  947. return browser_view_renderer_.OnDrawSoftware(canvas_holder->GetCanvas());
  948. }
  949. bool AwContents::NeedToDrawBackgroundColor(JNIEnv* env) {
  950. return browser_view_renderer_.NeedToDrawBackgroundColor();
  951. }
  952. void AwContents::SetPendingWebContentsForPopup(
  953. std::unique_ptr<content::WebContents> pending) {
  954. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  955. if (pending_contents_.get()) {
  956. // TODO(benm): Support holding multiple pop up window requests.
  957. LOG(WARNING) << "Blocking popup window creation as an outstanding "
  958. << "popup window is still pending.";
  959. base::ThreadTaskRunnerHandle::Get()->DeleteSoon(FROM_HERE,
  960. pending.release());
  961. return;
  962. }
  963. pending_contents_ = std::make_unique<AwContents>(std::move(pending));
  964. // Set dip_scale for pending contents, which is necessary for the later
  965. // SynchronousCompositor and InputHandler setup.
  966. pending_contents_->SetDipScaleInternal(browser_view_renderer_.dip_scale());
  967. }
  968. void AwContents::FocusFirstNode(JNIEnv* env) {
  969. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  970. web_contents_->FocusThroughTabTraversal(false);
  971. }
  972. void AwContents::SetBackgroundColor(JNIEnv* env, jint color) {
  973. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  974. web_contents_->SetPageBaseBackgroundColor(color);
  975. }
  976. void AwContents::ZoomBy(JNIEnv* env, jfloat delta) {
  977. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  978. browser_view_renderer_.ZoomBy(delta);
  979. }
  980. void AwContents::OnComputeScroll(JNIEnv* env, jlong animation_time_millis) {
  981. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  982. browser_view_renderer_.OnComputeScroll(
  983. base::TimeTicks() + base::Milliseconds(animation_time_millis));
  984. }
  985. jlong AwContents::ReleasePopupAwContents(JNIEnv* env) {
  986. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  987. return reinterpret_cast<intptr_t>(pending_contents_.release());
  988. }
  989. gfx::Point AwContents::GetLocationOnScreen() {
  990. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  991. JNIEnv* env = AttachCurrentThread();
  992. ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
  993. if (!obj)
  994. return gfx::Point();
  995. std::vector<int> location;
  996. base::android::JavaIntArrayToIntVector(
  997. env, Java_AwContents_getLocationOnScreen(env, obj), &location);
  998. return gfx::Point(location[0], location[1]);
  999. }
  1000. void AwContents::ScrollContainerViewTo(const gfx::Point& new_value) {
  1001. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  1002. JNIEnv* env = AttachCurrentThread();
  1003. ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
  1004. if (!obj)
  1005. return;
  1006. Java_AwContents_scrollContainerViewTo(env, obj, new_value.x(), new_value.y());
  1007. }
  1008. void AwContents::UpdateScrollState(const gfx::Point& max_scroll_offset,
  1009. const gfx::SizeF& contents_size_dip,
  1010. float page_scale_factor,
  1011. float min_page_scale_factor,
  1012. float max_page_scale_factor) {
  1013. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  1014. JNIEnv* env = AttachCurrentThread();
  1015. ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
  1016. if (!obj)
  1017. return;
  1018. Java_AwContents_updateScrollState(
  1019. env, obj, max_scroll_offset.x(), max_scroll_offset.y(),
  1020. contents_size_dip.width(), contents_size_dip.height(), page_scale_factor,
  1021. min_page_scale_factor, max_page_scale_factor);
  1022. }
  1023. void AwContents::DidOverscroll(const gfx::Vector2d& overscroll_delta,
  1024. const gfx::Vector2dF& overscroll_velocity,
  1025. bool inside_vsync) {
  1026. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  1027. JNIEnv* env = AttachCurrentThread();
  1028. ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
  1029. if (!obj)
  1030. return;
  1031. Java_AwContents_didOverscroll(env, obj, overscroll_delta.x(),
  1032. overscroll_delta.y(), overscroll_velocity.x(),
  1033. overscroll_velocity.y(), inside_vsync);
  1034. }
  1035. ui::TouchHandleDrawable* AwContents::CreateDrawable() {
  1036. JNIEnv* env = AttachCurrentThread();
  1037. const ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
  1038. if (!obj)
  1039. return nullptr;
  1040. return reinterpret_cast<ui::TouchHandleDrawable*>(
  1041. Java_AwContents_onCreateTouchHandle(env, obj));
  1042. }
  1043. void AwContents::SetDipScale(JNIEnv* env, jfloat dip_scale) {
  1044. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  1045. SetDipScaleInternal(dip_scale);
  1046. }
  1047. base::android::ScopedJavaLocalRef<jstring> AwContents::GetScheme(JNIEnv* env) {
  1048. return ConvertUTF8ToJavaString(env, scheme_);
  1049. }
  1050. void AwContents::OnInputEvent(JNIEnv* env) {
  1051. browser_view_renderer_.OnInputEvent();
  1052. }
  1053. void AwContents::SetDipScaleInternal(float dip_scale) {
  1054. browser_view_renderer_.SetDipScale(dip_scale);
  1055. }
  1056. void AwContents::ScrollTo(JNIEnv* env, jint x, jint y) {
  1057. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  1058. browser_view_renderer_.ScrollTo(gfx::Point(x, y));
  1059. }
  1060. void AwContents::RestoreScrollAfterTransition(JNIEnv* env, jint x, jint y) {
  1061. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  1062. browser_view_renderer_.RestoreScrollAfterTransition(gfx::Point(x, y));
  1063. }
  1064. void AwContents::SmoothScroll(JNIEnv* env,
  1065. jint target_x,
  1066. jint target_y,
  1067. jlong duration_ms) {
  1068. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  1069. float scale = browser_view_renderer_.page_scale_factor();
  1070. DCHECK_GE(duration_ms, 0);
  1071. render_view_host_ext_->SmoothScroll(target_x / scale, target_y / scale,
  1072. base::Milliseconds(duration_ms));
  1073. }
  1074. void AwContents::OnWebLayoutPageScaleFactorChanged(float page_scale_factor) {
  1075. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  1076. JNIEnv* env = AttachCurrentThread();
  1077. ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
  1078. if (!obj)
  1079. return;
  1080. Java_AwContents_onWebLayoutPageScaleFactorChanged(env, obj,
  1081. page_scale_factor);
  1082. }
  1083. void AwContents::OnWebLayoutContentsSizeChanged(
  1084. const gfx::Size& contents_size) {
  1085. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  1086. JNIEnv* env = AttachCurrentThread();
  1087. ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
  1088. if (!obj)
  1089. return;
  1090. gfx::Size contents_size_css =
  1091. ScaleToRoundedSize(contents_size, 1 / browser_view_renderer_.dip_scale());
  1092. Java_AwContents_onWebLayoutContentsSizeChanged(
  1093. env, obj, contents_size_css.width(), contents_size_css.height());
  1094. }
  1095. jlong AwContents::CapturePicture(JNIEnv* env, int width, int height) {
  1096. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  1097. return reinterpret_cast<intptr_t>(
  1098. new AwPicture(browser_view_renderer_.CapturePicture(width, height)));
  1099. }
  1100. void AwContents::EnableOnNewPicture(JNIEnv* env, jboolean enabled) {
  1101. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  1102. browser_view_renderer_.EnableOnNewPicture(enabled);
  1103. }
  1104. namespace {
  1105. void InvokeVisualStateCallback(const JavaObjectWeakGlobalRef& java_ref,
  1106. jlong request_id,
  1107. const JavaRef<jobject>& callback,
  1108. bool result) {
  1109. JNIEnv* env = AttachCurrentThread();
  1110. ScopedJavaLocalRef<jobject> obj = java_ref.get(env);
  1111. if (!obj)
  1112. return;
  1113. Java_AwContents_invokeVisualStateCallback(env, obj, callback, request_id);
  1114. }
  1115. } // namespace
  1116. void AwContents::InsertVisualStateCallback(
  1117. JNIEnv* env,
  1118. jlong request_id,
  1119. const JavaParamRef<jobject>& callback) {
  1120. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  1121. web_contents_->GetPrimaryMainFrame()->InsertVisualStateCallback(
  1122. base::BindOnce(&InvokeVisualStateCallback, java_ref_, request_id,
  1123. ScopedJavaGlobalRef<jobject>(env, callback)));
  1124. }
  1125. jint AwContents::GetEffectivePriority(JNIEnv* env) {
  1126. switch (web_contents_->GetPrimaryMainFrame()
  1127. ->GetProcess()
  1128. ->GetEffectiveImportance()) {
  1129. case content::ChildProcessImportance::NORMAL:
  1130. return static_cast<jint>(RendererPriority::WAIVED);
  1131. case content::ChildProcessImportance::MODERATE:
  1132. return static_cast<jint>(RendererPriority::LOW);
  1133. case content::ChildProcessImportance::IMPORTANT:
  1134. return static_cast<jint>(RendererPriority::HIGH);
  1135. }
  1136. NOTREACHED();
  1137. return 0;
  1138. }
  1139. JsCommunicationHost* AwContents::GetJsCommunicationHost() {
  1140. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  1141. if (!js_communication_host_.get()) {
  1142. js_communication_host_ =
  1143. std::make_unique<JsCommunicationHost>(web_contents_.get());
  1144. }
  1145. return js_communication_host_.get();
  1146. }
  1147. jint AwContents::AddDocumentStartJavaScript(
  1148. JNIEnv* env,
  1149. const base::android::JavaParamRef<jstring>& script,
  1150. const base::android::JavaParamRef<jobjectArray>& allowed_origin_rules) {
  1151. std::vector<std::string> native_allowed_origin_rule_strings;
  1152. AppendJavaStringArrayToStringVector(env, allowed_origin_rules,
  1153. &native_allowed_origin_rule_strings);
  1154. auto result = GetJsCommunicationHost()->AddDocumentStartJavaScript(
  1155. base::android::ConvertJavaStringToUTF16(env, script),
  1156. native_allowed_origin_rule_strings);
  1157. if (result.error_message) {
  1158. env->ThrowNew(env->FindClass("java/lang/IllegalArgumentException"),
  1159. result.error_message->data());
  1160. return -1;
  1161. }
  1162. DCHECK(result.script_id);
  1163. return result.script_id.value();
  1164. }
  1165. void AwContents::RemoveDocumentStartJavaScript(JNIEnv* env, jint script_id) {
  1166. GetJsCommunicationHost()->RemoveDocumentStartJavaScript(script_id);
  1167. }
  1168. base::android::ScopedJavaLocalRef<jstring> AwContents::AddWebMessageListener(
  1169. JNIEnv* env,
  1170. const base::android::JavaParamRef<jobject>& listener,
  1171. const base::android::JavaParamRef<jstring>& js_object_name,
  1172. const base::android::JavaParamRef<jobjectArray>& allowed_origin_rules) {
  1173. std::u16string native_js_object_name =
  1174. base::android::ConvertJavaStringToUTF16(env, js_object_name);
  1175. std::vector<std::string> native_allowed_origin_rule_strings;
  1176. AppendJavaStringArrayToStringVector(env, allowed_origin_rules,
  1177. &native_allowed_origin_rule_strings);
  1178. const std::u16string error_message =
  1179. GetJsCommunicationHost()->AddWebMessageHostFactory(
  1180. std::make_unique<AwWebMessageHostFactory>(listener),
  1181. native_js_object_name, native_allowed_origin_rule_strings);
  1182. if (error_message.empty())
  1183. return nullptr;
  1184. return base::android::ConvertUTF16ToJavaString(env, error_message);
  1185. }
  1186. void AwContents::RemoveWebMessageListener(
  1187. JNIEnv* env,
  1188. const base::android::JavaParamRef<jstring>& js_object_name) {
  1189. GetJsCommunicationHost()->RemoveWebMessageHostFactory(
  1190. ConvertJavaStringToUTF16(env, js_object_name));
  1191. }
  1192. base::android::ScopedJavaLocalRef<jobjectArray> AwContents::GetJsObjectsInfo(
  1193. JNIEnv* env,
  1194. const base::android::JavaParamRef<jclass>& clazz) {
  1195. if (js_communication_host_.get()) {
  1196. return AwWebMessageHostFactory::GetWebMessageListenerInfo(
  1197. GetJsCommunicationHost(), env, clazz);
  1198. }
  1199. return nullptr;
  1200. }
  1201. void AwContents::ClearView(JNIEnv* env) {
  1202. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  1203. browser_view_renderer_.ClearView();
  1204. }
  1205. void AwContents::SetExtraHeadersForUrl(
  1206. JNIEnv* env,
  1207. const JavaParamRef<jstring>& url,
  1208. const JavaParamRef<jstring>& jextra_headers) {
  1209. std::string extra_headers;
  1210. if (jextra_headers)
  1211. extra_headers = ConvertJavaStringToUTF8(env, jextra_headers);
  1212. AwResourceContext* resource_context = static_cast<AwResourceContext*>(
  1213. AwBrowserContext::FromWebContents(web_contents_.get())
  1214. ->GetResourceContext());
  1215. resource_context->SetExtraHeaders(GURL(ConvertJavaStringToUTF8(env, url)),
  1216. extra_headers);
  1217. }
  1218. void AwContents::SetJsOnlineProperty(JNIEnv* env, jboolean network_up) {
  1219. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  1220. AwRenderProcess* aw_render_process =
  1221. AwRenderProcess::GetInstanceForRenderProcessHost(
  1222. web_contents_->GetPrimaryMainFrame()->GetProcess());
  1223. aw_render_process->SetJsOnlineProperty(network_up);
  1224. }
  1225. void AwContents::TrimMemory(JNIEnv* env, jint level, jboolean visible) {
  1226. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  1227. // Constants from Android ComponentCallbacks2.
  1228. enum {
  1229. TRIM_MEMORY_RUNNING_LOW = 10,
  1230. TRIM_MEMORY_UI_HIDDEN = 20,
  1231. TRIM_MEMORY_BACKGROUND = 40,
  1232. TRIM_MEMORY_MODERATE = 60,
  1233. };
  1234. // Not urgent enough. TRIM_MEMORY_UI_HIDDEN is treated specially because
  1235. // it does not indicate memory pressure, but merely that the app is
  1236. // backgrounded.
  1237. if (level < TRIM_MEMORY_RUNNING_LOW || level == TRIM_MEMORY_UI_HIDDEN)
  1238. return;
  1239. // Do not release resources on view we expect to get DrawGL soon.
  1240. if (level < TRIM_MEMORY_BACKGROUND && visible)
  1241. return;
  1242. browser_view_renderer_.TrimMemory();
  1243. }
  1244. void AwContents::GrantFileSchemeAccesstoChildProcess(JNIEnv* env) {
  1245. content::ChildProcessSecurityPolicy::GetInstance()->GrantRequestScheme(
  1246. web_contents_->GetPrimaryMainFrame()->GetProcess()->GetID(),
  1247. url::kFileScheme);
  1248. }
  1249. void AwContents::ResumeLoadingCreatedPopupWebContents(JNIEnv* env) {
  1250. web_contents_->ResumeLoadingCreatedWebContents();
  1251. }
  1252. void JNI_AwContents_SetShouldDownloadFavicons(JNIEnv* env) {
  1253. g_should_download_favicons = true;
  1254. }
  1255. void AwContents::RenderViewHostChanged(content::RenderViewHost* old_host,
  1256. content::RenderViewHost* new_host) {
  1257. DCHECK(new_host);
  1258. // At this point, the current RVH may or may not contain a compositor. So
  1259. // compositor_ may be nullptr, in which case
  1260. // BrowserViewRenderer::DidInitializeCompositor() callback is time when the
  1261. // new compositor is constructed.
  1262. browser_view_renderer_.SetActiveFrameSinkId(
  1263. new_host->GetWidget()->GetFrameSinkId());
  1264. }
  1265. void AwContents::PrimaryPageChanged(content::Page& page) {
  1266. const url::Origin& origin = page.GetMainDocument().GetLastCommittedOrigin();
  1267. const std::string& scheme = origin.scheme();
  1268. const std::string& etld_plus1 =
  1269. net::registry_controlled_domains::GetDomainAndRegistry(
  1270. origin, net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES);
  1271. if (scheme_ != scheme) {
  1272. scheme_ = scheme;
  1273. AwBrowserProcess::GetInstance()
  1274. ->visibility_metrics_logger()
  1275. ->ClientVisibilityChanged(this);
  1276. }
  1277. if (scheme == url::kHttpsScheme || scheme == url::kHttpScheme) {
  1278. JNIEnv* env = AttachCurrentThread();
  1279. ScopedJavaLocalRef<jobject> j_ref = java_ref_.get(env);
  1280. if (j_ref) {
  1281. uint32_t origin_hash = base::PersistentHash(origin.Serialize());
  1282. uint32_t etld_plus1_hash = base::PersistentHash(etld_plus1);
  1283. jlong j_origin_hash = static_cast<jlong>(origin_hash);
  1284. jlong j_etld_plus1_hash = static_cast<jlong>(etld_plus1_hash);
  1285. Java_AwContents_logOriginVisit(env, j_ref, j_origin_hash);
  1286. Java_AwContents_logSiteVisit(env, j_ref, j_etld_plus1_hash);
  1287. }
  1288. }
  1289. }
  1290. void AwContents::DidFinishNavigation(
  1291. content::NavigationHandle* navigation_handle) {
  1292. // If this request was blocked in any way, broadcast an error.
  1293. net::Error error_code = navigation_handle->GetNetErrorCode();
  1294. if (!net::IsRequestBlockedError(error_code) &&
  1295. error_code != net::ERR_ABORTED) {
  1296. return;
  1297. }
  1298. // We do not call OnReceivedError for requests that were blocked due to an
  1299. // interstitial showing. OnReceivedError is handled directly by the blocking
  1300. // page for interstitials.
  1301. if (web_contents_) {
  1302. // We can't be showing an interstitial if there is no web_contents.
  1303. security_interstitials::SecurityInterstitialTabHelper*
  1304. security_interstitial_tab_helper = security_interstitials::
  1305. SecurityInterstitialTabHelper::FromWebContents(web_contents_.get());
  1306. if (security_interstitial_tab_helper &&
  1307. (security_interstitial_tab_helper->IsInterstitialPendingForNavigation(
  1308. navigation_handle->GetNavigationId()) ||
  1309. security_interstitial_tab_helper->IsDisplayingInterstitial())) {
  1310. return;
  1311. }
  1312. }
  1313. AwContentsClientBridge* client =
  1314. AwContentsClientBridge::FromWebContents(web_contents_.get());
  1315. if (!client)
  1316. return;
  1317. AwWebResourceRequest request(navigation_handle->GetURL().spec(),
  1318. navigation_handle->IsPost() ? "POST" : "GET",
  1319. navigation_handle->IsInPrimaryMainFrame(),
  1320. navigation_handle->HasUserGesture(),
  1321. net::HttpRequestHeaders());
  1322. request.is_renderer_initiated = navigation_handle->IsRendererInitiated();
  1323. client->OnReceivedError(request, error_code, false, false);
  1324. }
  1325. bool AwContents::CanShowInterstitial() {
  1326. JNIEnv* env = AttachCurrentThread();
  1327. const ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
  1328. if (!obj)
  1329. return false;
  1330. return Java_AwContents_canShowInterstitial(env, obj);
  1331. }
  1332. int AwContents::GetErrorUiType() {
  1333. JNIEnv* env = AttachCurrentThread();
  1334. const ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
  1335. if (!obj)
  1336. return false;
  1337. return Java_AwContents_getErrorUiType(env, obj);
  1338. }
  1339. VisibilityMetricsLogger::VisibilityInfo AwContents::GetVisibilityInfo() {
  1340. return VisibilityMetricsLogger::VisibilityInfo{
  1341. browser_view_renderer_.attached_to_window(),
  1342. browser_view_renderer_.view_visible(),
  1343. browser_view_renderer_.window_visible(),
  1344. VisibilityMetricsLogger::SchemeStringToEnum(scheme_)};
  1345. }
  1346. void AwContents::RendererUnresponsive(
  1347. content::RenderProcessHost* render_process_host) {
  1348. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  1349. JNIEnv* env = AttachCurrentThread();
  1350. ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
  1351. if (!obj)
  1352. return;
  1353. AwRenderProcess* aw_render_process =
  1354. AwRenderProcess::GetInstanceForRenderProcessHost(render_process_host);
  1355. Java_AwContents_onRendererUnresponsive(env, obj,
  1356. aw_render_process->GetJavaObject());
  1357. }
  1358. void AwContents::RendererResponsive(
  1359. content::RenderProcessHost* render_process_host) {
  1360. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  1361. JNIEnv* env = AttachCurrentThread();
  1362. ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
  1363. if (!obj)
  1364. return;
  1365. AwRenderProcess* aw_render_process =
  1366. AwRenderProcess::GetInstanceForRenderProcessHost(render_process_host);
  1367. Java_AwContents_onRendererResponsive(env, obj,
  1368. aw_render_process->GetJavaObject());
  1369. }
  1370. AwContents::RenderProcessGoneResult AwContents::OnRenderProcessGone(
  1371. int child_process_id,
  1372. bool crashed) {
  1373. DCHECK_CURRENTLY_ON(BrowserThread::UI);
  1374. JNIEnv* env = AttachCurrentThread();
  1375. ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
  1376. if (!obj)
  1377. return RenderProcessGoneResult::kHandled;
  1378. bool result =
  1379. Java_AwContents_onRenderProcessGone(env, obj, child_process_id, crashed);
  1380. if (HasException(env))
  1381. return RenderProcessGoneResult::kException;
  1382. return result ? RenderProcessGoneResult::kHandled
  1383. : RenderProcessGoneResult::kUnhandled;
  1384. }
  1385. } // namespace android_webview