Let ImeAdapterAndroid have the same lifecycle as its Java peer

content/browser/android/ime_adapter_android.cc

-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "content/browser/renderer_host/ime_adapter_android.h"
+#include "content/browser/android/ime_adapter_android.h"
 
+#include <android/input.h>
 #include <algorithm>
-#include <android/input.h>
 #include <vector>
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/android/scoped_java_ref.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
+#include "content/browser/frame_host/interstitial_page_impl.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/browser/renderer_host/render_view_host_delegate.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_view_android.h"
+#include "content/browser/web_contents/web_contents_impl.h"
 #include "content/common/input_messages.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/native_web_keyboard_event.h"
 #include "content/public/browser/web_contents.h"
 #include "jni/ImeAdapter_jni.h"
 #include "third_party/WebKit/public/platform/WebInputEvent.h"
 #include "third_party/WebKit/public/platform/WebTextInputType.h"
 #include "third_party/WebKit/public/web/WebCompositionUnderline.h"
 
 using base::android::AttachCurrentThread;
 using base::android::ConvertJavaStringToUTF16;
 using base::android::JavaParamRef;
+using base::android::ScopedJavaLocalRef;
 
 namespace content {
 namespace {
 
 // Maps a java KeyEvent into a NativeWebKeyboardEvent.
 // |java_key_event| is used to maintain a globalref for KeyEvent.
 // |type| will determine the WebInputEvent type.
 // type, |modifiers|, |time_ms|, |key_code|, |unicode_char| is used to create
 // WebKeyboardEvent. |key_code| is also needed ad need to treat the enter key
 // as a key press of character \r.
@@ skipping 12 matching lines @@
                                 modifiers, time_ms / 1000.0, key_code,
                                 scan_code, unicode_char, is_system_key);
 }
 
 }  // anonymous namespace
 
 bool RegisterImeAdapter(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
+jlong Init(JNIEnv* env,
+           const JavaParamRef<jobject>& obj,
+           const JavaParamRef<jobject>& jweb_contents) {
+  WebContents* web_contents = WebContents::FromJavaWebContents(jweb_contents);
+  DCHECK(web_contents);
+  return reinterpret_cast<intptr_t>(
+      new ImeAdapterAndroid(env, obj, web_contents));
+}
+
 // Callback from Java to convert BackgroundColorSpan data to a
 // blink::WebCompositionUnderline instance, and append it to |underlines_ptr|.
 void AppendBackgroundColorSpan(JNIEnv*,
                                const JavaParamRef<jclass>&,
                                jlong underlines_ptr,
                                jint start,
                                jint end,
                                jint background_color) {
   DCHECK_GE(start, 0);
   DCHECK_GE(end, 0);
   // Do not check |background_color|.
   std::vector<blink::WebCompositionUnderline>* underlines =
       reinterpret_cast<std::vector<blink::WebCompositionUnderline>*>(
           underlines_ptr);
-  underlines->push_back(
-      blink::WebCompositionUnderline(static_cast<unsigned>(start),
-                                     static_cast<unsigned>(end),
-                                     SK_ColorTRANSPARENT,
-                                     false,
-                                     static_cast<unsigned>(background_color)));
+  underlines->push_back(blink::WebCompositionUnderline(
+      static_cast<unsigned>(start), static_cast<unsigned>(end),
+      SK_ColorTRANSPARENT, false, static_cast<unsigned>(background_color)));
 }
 
 // Callback from Java to convert UnderlineSpan data to a
 // blink::WebCompositionUnderline instance, and append it to |underlines_ptr|.
 void AppendUnderlineSpan(JNIEnv*,
                          const JavaParamRef<jclass>&,
                          jlong underlines_ptr,
                          jint start,
                          jint end) {
   DCHECK_GE(start, 0);
   DCHECK_GE(end, 0);
   std::vector<blink::WebCompositionUnderline>* underlines =
       reinterpret_cast<std::vector<blink::WebCompositionUnderline>*>(
           underlines_ptr);
-  underlines->push_back(
-      blink::WebCompositionUnderline(static_cast<unsigned>(start),
-                                     static_cast<unsigned>(end),
-                                     SK_ColorBLACK,
-                                     false,
-                                     SK_ColorTRANSPARENT));
+  underlines->push_back(blink::WebCompositionUnderline(
+      static_cast<unsigned>(start), static_cast<unsigned>(end), SK_ColorBLACK,
+      false, SK_ColorTRANSPARENT));
 }
 
-ImeAdapterAndroid::ImeAdapterAndroid(RenderWidgetHostViewAndroid* rwhva)
-    : rwhva_(rwhva) {
-  DCHECK(rwhva_);
+ImeAdapterAndroid::ImeAdapterAndroid(JNIEnv* env,
+                                     const JavaParamRef<jobject>& obj,
+                                     WebContents* web_contents)
+    : WebContentsObserver(web_contents), rwhva_(nullptr) {
+  java_ime_adapter_ = JavaObjectWeakGlobalRef(env, obj);
 }
 
 ImeAdapterAndroid::~ImeAdapterAndroid() {
   JNIEnv* env = AttachCurrentThread();
-  base::android::ScopedJavaLocalRef<jobject> obj = java_ime_adapter_.get(env);
+  ScopedJavaLocalRef<jobject> obj = java_ime_adapter_.get(env);
   if (!obj.is_null())
-    Java_ImeAdapter_detach(env, obj);
+    Java_ImeAdapter_destroy(env, obj);
+
+  UpdateRenderProcessConnection(nullptr);
+}
+
+RenderWidgetHostViewAndroid* ImeAdapterAndroid::GetRenderWidgetHostViewAndroid()
+    const {
+  RenderWidgetHostView* rwhv = web_contents()->GetRenderWidgetHostView();
+  WebContentsImpl* web_contents_impl =
+      static_cast<WebContentsImpl*>(web_contents());
+  if (web_contents_impl->ShowingInterstitialPage()) {
+    rwhv = web_contents_impl->GetInterstitialPage()
+               ->GetMainFrame()
+               ->GetRenderViewHost()
+               ->GetWidget()
+               ->GetView();
+  }
+  return static_cast<RenderWidgetHostViewAndroid*>(rwhv);
+}
+
+void ImeAdapterAndroid::RenderViewReady() {
+  UpdateRenderProcessConnection(GetRenderWidgetHostViewAndroid());
+
+  JNIEnv* env = AttachCurrentThread();
+  ScopedJavaLocalRef<jobject> obj = java_ime_adapter_.get(env);
+  if (!obj.is_null())
+    Java_ImeAdapter_onConnectedToRenderProcess(env, obj);
+}
+
+void ImeAdapterAndroid::RenderViewHostChanged(RenderViewHost* old_host,
+                                              RenderViewHost* new_host) {
+  if (new_host) {
+    UpdateRenderProcessConnection(static_cast<RenderWidgetHostViewAndroid*>(
+        new_host->GetWidget()->GetView()));
+  } else {
+    UpdateRenderProcessConnection(nullptr);
+  }
+}
+
+void ImeAdapterAndroid::DidAttachInterstitialPage() {
+  UpdateRenderProcessConnection(GetRenderWidgetHostViewAndroid());
+}
+
+void ImeAdapterAndroid::DidDetachInterstitialPage() {
+  UpdateRenderProcessConnection(GetRenderWidgetHostViewAndroid());
+}
+
+void ImeAdapterAndroid::WebContentsDestroyed() {
+  delete this;
+}
+
+void ImeAdapterAndroid::UpdateRenderProcessConnection(
+    RenderWidgetHostViewAndroid* new_rwhva) {
+  if (rwhva_.get() == new_rwhva)
+    return;
+  if (rwhva_)
+    rwhva_->set_ime_adapter(nullptr);
+  if (new_rwhva) {
+    new_rwhva->set_ime_adapter(this);
+    rwhva_ = new_rwhva->GetWeakPtrAndroid();
+  } else {
+    rwhva_.reset();
+  }
 }
 
 bool ImeAdapterAndroid::SendKeyEvent(
     JNIEnv* env,
     const JavaParamRef<jobject>&,
     const JavaParamRef<jobject>& original_key_event,
     int type,
     int modifiers,
     jlong time_ms,
     int key_code,
     int scan_code,
     bool is_system_key,
     int unicode_char) {
+  if (!rwhva_)
+    return false;
   NativeWebKeyboardEvent event = NativeWebKeyboardEventFromKeyEvent(
       env, original_key_event, type, modifiers, time_ms, key_code, scan_code,
       is_system_key, unicode_char);
   rwhva_->SendKeyEvent(event);
   return true;
 }
 
 void ImeAdapterAndroid::SetComposingText(JNIEnv* env,
                                          const JavaParamRef<jobject>& obj,
                                          const JavaParamRef<jobject>& text,
@@ skipping 52 matching lines @@
 
 void ImeAdapterAndroid::FinishComposingText(JNIEnv* env,
                                             const JavaParamRef<jobject>&) {
   RenderWidgetHostImpl* rwhi = GetFocusedWidget();
   if (!rwhi)
     return;
 
   rwhi->ImeFinishComposingText(true);
 }
 
-void ImeAdapterAndroid::AttachImeAdapter(
-    JNIEnv* env,
-    const JavaParamRef<jobject>& java_object) {
-  java_ime_adapter_ = JavaObjectWeakGlobalRef(env, java_object);
-}
-
 void ImeAdapterAndroid::CancelComposition() {
-  base::android::ScopedJavaLocalRef<jobject> obj =
-      java_ime_adapter_.get(AttachCurrentThread());
+  JNIEnv* env = AttachCurrentThread();
+  ScopedJavaLocalRef<jobject> obj = java_ime_adapter_.get(env);
   if (!obj.is_null())
-    Java_ImeAdapter_cancelComposition(AttachCurrentThread(), obj);
+    Java_ImeAdapter_cancelComposition(env, obj);
 }
 
 void ImeAdapterAndroid::FocusedNodeChanged(bool is_editable_node) {
-  base::android::ScopedJavaLocalRef<jobject> obj =
-      java_ime_adapter_.get(AttachCurrentThread());
+  JNIEnv* env = AttachCurrentThread();
+  ScopedJavaLocalRef<jobject> obj = java_ime_adapter_.get(env);
   if (!obj.is_null()) {
-    Java_ImeAdapter_focusedNodeChanged(AttachCurrentThread(), obj,
-                                       is_editable_node);
+    Java_ImeAdapter_focusedNodeChanged(env, obj, is_editable_node);
   }
 }
 
 void ImeAdapterAndroid::SetEditableSelectionOffsets(
     JNIEnv*,
     const JavaParamRef<jobject>&,
     int start,
     int end) {
   RenderFrameHost* rfh = GetFocusedFrame();
   if (!rfh)
     return;
 
   rfh->Send(new InputMsg_SetEditableSelectionOffsets(rfh->GetRoutingID(), start,
                                                      end));
 }
 
 void ImeAdapterAndroid::SetCharacterBounds(
     const std::vector<gfx::RectF>& character_bounds) {
   JNIEnv* env = AttachCurrentThread();
-  base::android::ScopedJavaLocalRef<jobject> obj = java_ime_adapter_.get(env);
+  ScopedJavaLocalRef<jobject> obj = java_ime_adapter_.get(env);
   if (obj.is_null())
     return;
 
   const size_t coordinates_array_size = character_bounds.size() * 4;
   std::unique_ptr<float[]> coordinates_array(new float[coordinates_array_size]);
   for (size_t i = 0; i < character_bounds.size(); ++i) {
     const gfx::RectF& rect = character_bounds[i];
     const size_t coordinates_array_index = i * 4;
     coordinates_array[coordinates_array_index + 0] = rect.x();
     coordinates_array[coordinates_array_index + 1] = rect.y();
     coordinates_array[coordinates_array_index + 2] = rect.right();
     coordinates_array[coordinates_array_index + 3] = rect.bottom();
   }
   Java_ImeAdapter_setCharacterBounds(
-      env, obj, base::android::ToJavaFloatArray(env, coordinates_array.get(),
-                                                coordinates_array_size));
+      env, obj,
+      base::android::ToJavaFloatArray(env, coordinates_array.get(),
+                                      coordinates_array_size));
 }
 
 void ImeAdapterAndroid::SetComposingRegion(JNIEnv*,
                                            const JavaParamRef<jobject>&,
                                            int start,
                                            int end) {
   RenderFrameHost* rfh = GetFocusedFrame();
   if (!rfh)
     return;
 
@@ skipping 41 matching lines @@
     const base::android::JavaParamRef<jobject>& obj,
     bool immediate_request,
     bool monitor_request) {
   RenderWidgetHostImpl* rwhi = GetFocusedWidget();
   if (!rwhi)
     return;
   rwhi->Send(new InputMsg_RequestCompositionUpdates(
       rwhi->GetRoutingID(), immediate_request, monitor_request));
 }
 
-void ImeAdapterAndroid::ResetImeAdapter(JNIEnv* env,
-                                        const JavaParamRef<jobject>&) {
-  java_ime_adapter_.reset();
-}
-
 RenderWidgetHostImpl* ImeAdapterAndroid::GetFocusedWidget() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  return rwhva_->GetFocusedWidget();
+  return rwhva_ ? rwhva_->GetFocusedWidget() : nullptr;
 }
 
 RenderFrameHost* ImeAdapterAndroid::GetFocusedFrame() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // We get the focused frame from the WebContents of the page. Although
   // |rwhva_->GetFocusedWidget()| does a similar thing, there is no direct way
   // to get a RenderFrameHost from its RWH.
+  if (!rwhva_)
+    return nullptr;
   RenderWidgetHostImpl* rwh =
       RenderWidgetHostImpl::From(rwhva_->GetRenderWidgetHost());
   if (!rwh || !rwh->delegate())
     return nullptr;
 
   if (auto* contents = rwh->delegate()->GetAsWebContents())
     return contents->GetFocusedFrame();
 
   return nullptr;
 }
@@ skipping 11 matching lines @@
   Java_ImeAdapter_populateUnderlinesFromSpans(
       env, obj, text, reinterpret_cast<jlong>(&underlines));
 
   // Sort spans by |.startOffset|.
   std::sort(underlines.begin(), underlines.end());
 
   return underlines;
 }
 
 }  // namespace content