src/content/browser/android/web_contents_observer_android.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/browser/android/web_contents_observer_android.h"
   6
   7 #include <string>
   8
   9 #include <jni.h>
  10
  11 #include "base/android/jni_android.h"
  12 #include "base/android/jni_string.h"
  13 #include "base/android/scoped_java_ref.h"
  14 #include "content/browser/android/content_view_core_impl.h"
  15 #include "content/browser/renderer_host/render_widget_host_impl.h"
  16 #include "content/browser/web_contents/web_contents_impl.h"
  17 #include "content/public/browser/navigation_details.h"
  18 #include "content/public/browser/navigation_entry.h"
  19 #include "jni/WebContentsObserverAndroid_jni.h"
  20
  21 using base::android::AttachCurrentThread;
  22 using base::android::ScopedJavaLocalRef;
  23 using base::android::ConvertUTF8ToJavaString;
  24 using base::android::ConvertUTF16ToJavaString;
  25
  26 namespace content {
  27
  28 WebContentsObserverAndroid::WebContentsObserverAndroid(
  29     JNIEnv* env,
  30     jobject obj,
  31     WebContents* web_contents)
  32     : WebContentsObserver(web_contents),
  33       weak_java_observer_(env, obj){
  34 }
  35
  36 WebContentsObserverAndroid::~WebContentsObserverAndroid() {
  37 }
  38
  39 jlong Init(JNIEnv* env, jobject obj, jlong native_content_view_core) {
  40   ContentViewCore* content_view_core =
  41       reinterpret_cast<ContentViewCore*>(native_content_view_core);
  42   WebContentsObserverAndroid* native_observer = new WebContentsObserverAndroid(
  43       env, obj, content_view_core->GetWebContents());
  44   return reinterpret_cast<intptr_t>(native_observer);
  45 }
  46
  47 void WebContentsObserverAndroid::Destroy(JNIEnv* env, jobject obj) {
  48   delete this;
  49 }
  50
  51 void WebContentsObserverAndroid::WebContentsDestroyed() {
  52   JNIEnv* env = AttachCurrentThread();
  53   ScopedJavaLocalRef<jobject> obj(weak_java_observer_.get(env));
  54   if (obj.is_null()) {
  55     delete this;
  56   } else {
  57     // The java side will destroy |this|
  58     Java_WebContentsObserverAndroid_detachFromWebContents(env, obj.obj());
  59   }
  60 }
  61
  62 void WebContentsObserverAndroid::RenderProcessGone(
  63     base::TerminationStatus termination_status) {
  64   JNIEnv* env = AttachCurrentThread();
  65   ScopedJavaLocalRef<jobject> obj(weak_java_observer_.get(env));
  66   if (obj.is_null())
  67     return;
  68   jboolean was_oom_protected =
  69       termination_status == base::TERMINATION_STATUS_OOM_PROTECTED;
  70   Java_WebContentsObserverAndroid_renderProcessGone(
  71       env, obj.obj(), was_oom_protected);
  72 }
  73
  74 void WebContentsObserverAndroid::DidStartLoading(
  75     RenderViewHost* render_view_host) {
  76   JNIEnv* env = AttachCurrentThread();
  77   ScopedJavaLocalRef<jobject> obj(weak_java_observer_.get(env));
  78   if (obj.is_null())
  79     return;
  80   ScopedJavaLocalRef<jstring> jstring_url(ConvertUTF8ToJavaString(
  81       env, web_contents()->GetVisibleURL().spec()));
  82   Java_WebContentsObserverAndroid_didStartLoading(
  83       env, obj.obj(), jstring_url.obj());
  84 }
  85
  86 void WebContentsObserverAndroid::DidStopLoading(
  87     RenderViewHost* render_view_host) {
  88   JNIEnv* env = AttachCurrentThread();
  89   ScopedJavaLocalRef<jobject> obj(weak_java_observer_.get(env));
  90   if (obj.is_null())
  91     return;
  92   ScopedJavaLocalRef<jstring> jstring_url(ConvertUTF8ToJavaString(
  93       env, web_contents()->GetLastCommittedURL().spec()));
  94   Java_WebContentsObserverAndroid_didStopLoading(
  95       env, obj.obj(), jstring_url.obj());
  96 }
  97
  98 void WebContentsObserverAndroid::DidFailProvisionalLoad(
  99     int64 frame_id,
 100     const base::string16& frame_unique_name,
 101     bool is_main_frame,
 102     const GURL& validated_url,
 103     int error_code,
 104     const base::string16& error_description,
 105     RenderViewHost* render_view_host) {
 106   DidFailLoadInternal(
 107         true, is_main_frame, error_code, error_description, validated_url);
 108 }
 109
 110 void WebContentsObserverAndroid::DidFailLoad(
 111     int64 frame_id,
 112     const GURL& validated_url,
 113     bool is_main_frame,
 114     int error_code,
 115     const base::string16& error_description,
 116     RenderViewHost* render_view_host) {
 117   DidFailLoadInternal(
 118         false, is_main_frame, error_code, error_description, validated_url);
 119 }
 120
 121 void WebContentsObserverAndroid::DidNavigateMainFrame(
 122     const LoadCommittedDetails& details,
 123     const FrameNavigateParams& params) {
 124   JNIEnv* env = AttachCurrentThread();
 125   ScopedJavaLocalRef<jobject> obj(weak_java_observer_.get(env));
 126   if (obj.is_null())
 127     return;
 128   ScopedJavaLocalRef<jstring> jstring_url(
 129       ConvertUTF8ToJavaString(env, params.url.spec()));
 130   ScopedJavaLocalRef<jstring> jstring_base_url(
 131       ConvertUTF8ToJavaString(env, params.base_url.spec()));
 132   // See http://crbug.com/251330 for why it's determined this way.
 133   bool in_page_navigation =
 134       details.type == NAVIGATION_TYPE_IN_PAGE || details.is_in_page;
 135   Java_WebContentsObserverAndroid_didNavigateMainFrame(
 136       env, obj.obj(), jstring_url.obj(), jstring_base_url.obj(),
 137       details.is_navigation_to_different_page(), in_page_navigation);
 138 }
 139
 140 void WebContentsObserverAndroid::DidNavigateAnyFrame(
 141     const LoadCommittedDetails& details,
 142     const FrameNavigateParams& params) {
 143   JNIEnv* env = AttachCurrentThread();
 144   ScopedJavaLocalRef<jobject> obj(weak_java_observer_.get(env));
 145   if (obj.is_null())
 146     return;
 147   ScopedJavaLocalRef<jstring> jstring_url(
 148       ConvertUTF8ToJavaString(env, params.url.spec()));
 149   ScopedJavaLocalRef<jstring> jstring_base_url(
 150       ConvertUTF8ToJavaString(env, params.base_url.spec()));
 151   jboolean jboolean_is_reload =
 152       PageTransitionCoreTypeIs(params.transition, PAGE_TRANSITION_RELOAD);
 153
 154   Java_WebContentsObserverAndroid_didNavigateAnyFrame(
 155       env, obj.obj(), jstring_url.obj(), jstring_base_url.obj(),
 156       jboolean_is_reload);
 157 }
 158
 159 void WebContentsObserverAndroid::DidStartProvisionalLoadForFrame(
 160       int64 frame_id,
 161       int64 parent_frame_id,
 162       bool is_main_frame,
 163       const GURL& validated_url,
 164       bool is_error_page,
 165       bool is_iframe_srcdoc,
 166       RenderViewHost* render_view_host) {
 167   JNIEnv* env = AttachCurrentThread();
 168   ScopedJavaLocalRef<jobject> obj(weak_java_observer_.get(env));
 169   if (obj.is_null())
 170     return;
 171   ScopedJavaLocalRef<jstring> jstring_url(
 172       ConvertUTF8ToJavaString(env, validated_url.spec()));
 173   Java_WebContentsObserverAndroid_didStartProvisionalLoadForFrame(
 174       env, obj.obj(), frame_id, parent_frame_id, is_main_frame,
 175       jstring_url.obj(), is_error_page, is_iframe_srcdoc);
 176 }
 177
 178 void WebContentsObserverAndroid::DidCommitProvisionalLoadForFrame(
 179       int64 frame_id,
 180       const base::string16& frame_unique_name,
 181       bool is_main_frame,
 182       const GURL& url,
 183       PageTransition transition_type,
 184       RenderViewHost* render_view_host) {
 185   JNIEnv* env = AttachCurrentThread();
 186   ScopedJavaLocalRef<jobject> obj(weak_java_observer_.get(env));
 187   if (obj.is_null())
 188     return;
 189   ScopedJavaLocalRef<jstring> jstring_url(
 190       ConvertUTF8ToJavaString(env, url.spec()));
 191   Java_WebContentsObserverAndroid_didCommitProvisionalLoadForFrame(
 192       env, obj.obj(), frame_id, is_main_frame, jstring_url.obj(),
 193       transition_type);
 194 }
 195
 196 void WebContentsObserverAndroid::DidFinishLoad(
 197     int64 frame_id,
 198     const GURL& validated_url,
 199     bool is_main_frame,
 200     RenderViewHost* render_view_host) {
 201   JNIEnv* env = AttachCurrentThread();
 202   ScopedJavaLocalRef<jobject> obj(weak_java_observer_.get(env));
 203   if (obj.is_null())
 204     return;
 205
 206   std::string url_string = validated_url.spec();
 207   NavigationEntry* entry =
 208     web_contents()->GetController().GetLastCommittedEntry();
 209   // Note that GetBaseURLForDataURL is only used by the Android WebView.
 210   if (entry && !entry->GetBaseURLForDataURL().is_empty())
 211     url_string = entry->GetBaseURLForDataURL().possibly_invalid_spec();
 212
 213   ScopedJavaLocalRef<jstring> jstring_url(
 214       ConvertUTF8ToJavaString(env, url_string));
 215   Java_WebContentsObserverAndroid_didFinishLoad(
 216       env, obj.obj(), frame_id, jstring_url.obj(), is_main_frame);
 217 }
 218
 219 void WebContentsObserverAndroid::NavigationEntryCommitted(
 220     const LoadCommittedDetails& load_details) {
 221   JNIEnv* env = AttachCurrentThread();
 222   ScopedJavaLocalRef<jobject> obj(weak_java_observer_.get(env));
 223   if (obj.is_null())
 224     return;
 225   Java_WebContentsObserverAndroid_navigationEntryCommitted(env, obj.obj());
 226 }
 227
 228 void WebContentsObserverAndroid::DidChangeVisibleSSLState() {
 229   JNIEnv* env = AttachCurrentThread();
 230   ScopedJavaLocalRef<jobject> obj(weak_java_observer_.get(env));
 231   if (obj.is_null())
 232     return;
 233   Java_WebContentsObserverAndroid_didChangeVisibleSSLState(env, obj.obj());
 234 }
 235
 236 void WebContentsObserverAndroid::DidAttachInterstitialPage() {
 237   JNIEnv* env = AttachCurrentThread();
 238   ScopedJavaLocalRef<jobject> obj(weak_java_observer_.get(env));
 239   if (obj.is_null())
 240     return;
 241   Java_WebContentsObserverAndroid_didAttachInterstitialPage(env, obj.obj());
 242 }
 243
 244 void WebContentsObserverAndroid::DidDetachInterstitialPage() {
 245   JNIEnv* env = AttachCurrentThread();
 246   ScopedJavaLocalRef<jobject> obj(weak_java_observer_.get(env));
 247   if (obj.is_null())
 248     return;
 249   Java_WebContentsObserverAndroid_didDetachInterstitialPage(env, obj.obj());
 250 }
 251
 252 void WebContentsObserverAndroid::DidFailLoadInternal(
 253     bool is_provisional_load,
 254     bool is_main_frame,
 255     int error_code,
 256     const base::string16& description,
 257     const GURL& url) {
 258   JNIEnv* env = AttachCurrentThread();
 259   ScopedJavaLocalRef<jobject> obj(weak_java_observer_.get(env));
 260   if (obj.is_null())
 261     return;
 262   ScopedJavaLocalRef<jstring> jstring_error_description(
 263       ConvertUTF16ToJavaString(env, description));
 264   ScopedJavaLocalRef<jstring> jstring_url(
 265       ConvertUTF8ToJavaString(env, url.spec()));
 266
 267   Java_WebContentsObserverAndroid_didFailLoad(
 268       env, obj.obj(),
 269       is_provisional_load,
 270       is_main_frame,
 271       error_code,
 272       jstring_error_description.obj(), jstring_url.obj());
 273 }
 274
 275 void WebContentsObserverAndroid::DidFirstVisuallyNonEmptyPaint() {
 276   JNIEnv* env = AttachCurrentThread();
 277   ScopedJavaLocalRef<jobject> obj(weak_java_observer_.get(env));
 278   if (obj.is_null())
 279     return;
 280   Java_WebContentsObserverAndroid_didFirstVisuallyNonEmptyPaint(
 281       env, obj.obj());
 282 }
 283
 284 bool RegisterWebContentsObserverAndroid(JNIEnv* env) {
 285   return RegisterNativesImpl(env);
 286 }
 287 }  // namespace content