Have WebContentsViewAndroid own ViewAndroid

content/browser/android/content_view_core_impl.cc

 // Copyright 2012 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/android/content_view_core_impl.h"
 
 #include <stddef.h>
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
@@ skipping 189 matching lines @@
 // static
 ContentViewCore* ContentViewCore::FromWebContents(
     content::WebContents* web_contents) {
   return ContentViewCoreImpl::FromWebContents(web_contents);
 }
 
 ContentViewCoreImpl::ContentViewCoreImpl(
     JNIEnv* env,
     const JavaRef<jobject>& obj,
     WebContents* web_contents,
-    const JavaRef<jobject>& view_android_delegate,
-    ui::WindowAndroid* window_android,
     const JavaRef<jobject>& java_bridge_retained_object_set)
     : WebContentsObserver(web_contents),
       java_ref_(env, obj),
-      view_(view_android_delegate),
       web_contents_(static_cast<WebContentsImpl*>(web_contents)),
       page_scale_(1),
-      dpi_scale_(ui::GetScaleFactorForNativeView(&view_)),
+      dpi_scale_(ui::GetScaleFactorForNativeView(GetViewAndroid())),
       device_orientation_(0),
       accessibility_enabled_(false) {
-  CHECK(web_contents) <<
-      "A ContentViewCoreImpl should be created with a valid WebContents.";
-  DCHECK(window_android);
-  DCHECK(!view_android_delegate.is_null());
-  window_android->AddChild(&view_);
-  view_.SetLayer(cc::Layer::Create());
+  GetViewAndroid()->SetLayer(cc::Layer::Create());
   gfx::Size physical_size(
       Java_ContentViewCore_getPhysicalBackingWidthPix(env, obj),
       Java_ContentViewCore_getPhysicalBackingHeightPix(env, obj));
-  view_.GetLayer()->SetBounds(physical_size);
+  GetViewAndroid()->GetLayer()->SetBounds(physical_size);
 
   // Currently, the only use case we have for overriding a user agent involves
   // spoofing a desktop Linux user agent for "Request desktop site".
   // Automatically set it for all WebContents so that it is available when a
   // NavigationEntry requires the user agent to be overridden.
   const char kLinuxInfoStr[] = "X11; Linux x86_64";
   std::string product = content::GetContentClient()->GetProduct();
   std::string spoofed_ua =
       BuildUserAgentFromOSAndProduct(kLinuxInfoStr, product);
   web_contents->SetUserAgentOverride(spoofed_ua);
 
   java_bridge_dispatcher_host_ =
       new GinJavaBridgeDispatcherHost(web_contents,
                                       java_bridge_retained_object_set);
 
   InitWebContents();
 }
 
 void ContentViewCoreImpl::AddObserver(
     ContentViewCoreImplObserver* observer) {
   observer_list_.AddObserver(observer);
 }
 
 void ContentViewCoreImpl::RemoveObserver(
     ContentViewCoreImplObserver* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
 ContentViewCoreImpl::~ContentViewCoreImpl() {
-  view_.GetLayer()->RemoveFromParent();
   for (auto& observer : observer_list_)
     observer.OnContentViewCoreDestroyed();
   observer_list_.Clear();
 
   JNIEnv* env = base::android::AttachCurrentThread();
   ScopedJavaLocalRef<jobject> j_obj = java_ref_.get(env);
   java_ref_.reset();
   if (!j_obj.is_null()) {
     Java_ContentViewCore_onNativeContentViewCoreDestroyed(
         env, j_obj, reinterpret_cast<intptr_t>(this));
   }
 }
 
 void ContentViewCoreImpl::UpdateWindowAndroid(
     JNIEnv* env,
     const base::android::JavaParamRef<jobject>& obj,
     jlong window_android) {
+  ui::ViewAndroid* view = GetViewAndroid();
   if (window_android) {
-    DCHECK(!view_.GetWindowAndroid());
+    DCHECK(!GetWindowAndroid());
     ui::WindowAndroid* window =
         reinterpret_cast<ui::WindowAndroid*>(window_android);
-    window->AddChild(&view_);
+    window->AddChild(view);
     for (auto& observer : observer_list_)
       observer.OnAttachedToWindow();
   } else {
     for (auto& observer : observer_list_)
       observer.OnDetachedFromWindow();
-    view_.RemoveFromParent();
+    view->RemoveFromParent();
   }
 }
 
 base::android::ScopedJavaLocalRef<jobject>
 ContentViewCoreImpl::GetWebContentsAndroid(JNIEnv* env,
                                            const JavaParamRef<jobject>& obj) {
   return web_contents_->GetJavaWebContents();
 }
 
 base::android::ScopedJavaLocalRef<jobject>
 ContentViewCoreImpl::GetJavaWindowAndroid(JNIEnv* env,
                                           const JavaParamRef<jobject>& obj) {
-  if (!view_.GetWindowAndroid())
+  if (!GetWindowAndroid())
     return ScopedJavaLocalRef<jobject>();
-  return view_.GetWindowAndroid()->GetJavaObject();
+  return GetWindowAndroid()->GetJavaObject();
 }
 
 void ContentViewCoreImpl::OnJavaContentViewCoreDestroyed(
     JNIEnv* env,
     const JavaParamRef<jobject>& obj) {
   DCHECK(env->IsSameObject(java_ref_.get(env).obj(), obj));
   java_ref_.reset();
   // Java peer has gone, ContentViewCore is not functional and waits to
   // be destroyed with WebContents.
   // We need to reset WebContentsViewAndroid's reference, otherwise, there
@@ skipping 95 matching lines @@
     const gfx::SizeF& content_size,
     const gfx::SizeF& viewport_size,
     const float top_controls_height,
     const float top_controls_shown_ratio,
     const float bottom_controls_height,
     const float bottom_controls_shown_ratio,
     bool is_mobile_optimized_hint,
     const gfx::SelectionBound& selection_start) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
-  if (obj.is_null() || !view_.GetWindowAndroid())
+  if (obj.is_null() || !GetWindowAndroid())
     return;
 
-  view_.GetWindowAndroid()->set_content_offset(
+  GetWindowAndroid()->set_content_offset(
       gfx::Vector2dF(0.0f, top_controls_height * top_controls_shown_ratio));
 
   page_scale_ = page_scale_factor;
 
   // The CursorAnchorInfo API in Android only supports zero width selection
   // bounds.
   const jboolean has_insertion_marker =
       selection_start.type() == gfx::SelectionBound::CENTER;
   const jboolean is_insertion_marker_visible = selection_start.visible();
   const jfloat insertion_marker_horizontal =
@@ skipping 73 matching lines @@
   for (size_t i = 0; i < items.size(); ++i) {
     labels.push_back(items[i].label);
     jint enabled =
         (items[i].type == MenuItem::GROUP ? POPUP_ITEM_TYPE_GROUP :
             (items[i].enabled ? POPUP_ITEM_TYPE_ENABLED :
                 POPUP_ITEM_TYPE_DISABLED));
     env->SetIntArrayRegion(enabled_array.obj(), i, 1, &enabled);
   }
   ScopedJavaLocalRef<jobjectArray> items_array(
       base::android::ToJavaArrayOfStrings(env, labels));
-  select_popup_ = view_.AcquireAnchorView();
+  ui::ViewAndroid* view = GetViewAndroid();
+  select_popup_ = view->AcquireAnchorView();
   const ScopedJavaLocalRef<jobject> popup_view = select_popup_.view();
   if (popup_view.is_null())
     return;
-  view_.SetAnchorRect(popup_view,
+  view->SetAnchorRect(popup_view,
                       gfx::ScaleRect(gfx::RectF(bounds), page_scale_));
   Java_ContentViewCore_showSelectPopup(
       env, j_obj, popup_view, reinterpret_cast<intptr_t>(frame), items_array,
       enabled_array, multiple, selected_array, right_aligned);
 }
 
 void ContentViewCoreImpl::HideSelectPopupMenu() {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> j_obj = java_ref_.get(env);
   if (!j_obj.is_null())
@@ skipping 276 matching lines @@
 
   gfx::Point base_point = gfx::ToRoundedPoint(base);
   gfx::Point extent_point = gfx::ToRoundedPoint(extent);
   if (base_point == extent_point)
     return;
 
   web_contents_->SelectRange(base_point, extent_point);
 }
 
 ui::WindowAndroid* ContentViewCoreImpl::GetWindowAndroid() const {
-  return view_.GetWindowAndroid();
+  return GetViewAndroid()->GetWindowAndroid();
 }
 
-ui::ViewAndroid* ContentViewCoreImpl::GetViewAndroid() {
-  return &view_;
+ui::ViewAndroid* ContentViewCoreImpl::GetViewAndroid() const {
+  return web_contents_->GetView()->GetNativeView();
 }
 
 
 // ----------------------------------------------------------------------------
 // Methods called from Java via JNI
 // ----------------------------------------------------------------------------
 
 void ContentViewCoreImpl::SelectPopupMenuItems(
     JNIEnv* env,
     const JavaParamRef<jobject>& obj,
@@ skipping 391 matching lines @@
   java_bridge_dispatcher_host_->RemoveNamedObject(
       ConvertJavaStringToUTF8(env, name));
 }
 
 void ContentViewCoreImpl::WasResized(JNIEnv* env,
                                      const JavaParamRef<jobject>& obj) {
   RenderWidgetHostViewAndroid* view = GetRenderWidgetHostViewAndroid();
   gfx::Size physical_size(
       Java_ContentViewCore_getPhysicalBackingWidthPix(env, obj),
       Java_ContentViewCore_getPhysicalBackingHeightPix(env, obj));
-  view_.GetLayer()->SetBounds(physical_size);
+  GetViewAndroid()->GetLayer()->SetBounds(physical_size);
 
   if (view) {
     web_contents_->SendScreenRects();
     view->WasResized();
   }
 }
 
 long ContentViewCoreImpl::GetNativeImeAdapter(
     JNIEnv* env,
     const JavaParamRef<jobject>& obj) {
@@ skipping 108 matching lines @@
     if (web_contents_) {
       web_contents_->SetAccessibilityMode(
           accessibility_state->accessibility_mode());
     }
   }
 }
 
 void ContentViewCoreImpl::SendOrientationChangeEventInternal() {
   RenderWidgetHostViewAndroid* rwhv = GetRenderWidgetHostViewAndroid();
   if (rwhv)
-    rwhv->UpdateScreenInfo(&view_);
+    rwhv->UpdateScreenInfo(GetViewAndroid());
 
   static_cast<WebContentsImpl*>(web_contents())->
       screen_orientation_dispatcher_host()->OnOrientationChange();
 }
 
 void ContentViewCoreImpl::ExtractSmartClipData(JNIEnv* env,
                                                const JavaParamRef<jobject>& obj,
                                                jint x,
                                                jint y,
                                                jint width,
@@ skipping 162 matching lines @@
 void ContentViewCoreImpl::PullReset() {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (!obj.is_null())
     Java_ContentViewCore_onOverscrollRefreshReset(env, obj);
 }
 
 // This is called for each ContentView.
 jlong Init(JNIEnv* env,
            const JavaParamRef<jobject>& obj,
-           const JavaParamRef<jobject>& web_contents,
-           const JavaParamRef<jobject>& view_android_delegate,
+           const JavaParamRef<jobject>& jweb_contents,
+           const JavaParamRef<jobject>& jview_android_delegate,
            jlong window_android,
            const JavaParamRef<jobject>& retained_objects_set) {
+  WebContentsImpl* web_contents = static_cast<WebContentsImpl*>(
+      WebContents::FromJavaWebContents(jweb_contents));
+  CHECK(web_contents) <<
+      "A ContentViewCoreImpl should be created with a valid WebContents.";
+  web_contents->GetView()->CreateView(

[boliu, 2016/10/28 15:58:58]

it's not ok to just reuse this call to *set* ViewAndroid. the meaning of
CreateView is for it to the call to create a *new* NativeView, and possibly used
the passed in NativeView as a context

I think easiest thing for now is have ViewAndroid get its delegate after
construction, perhaps in an Init method as well. Then you can keep creating
ViewAndroid in WebContentsViewAndroid instance (ie not with unique_ptr),
CreateView can keep being a no-op. And then you can set the delegate here

[Jinsuk Kim, 2016/10/31 01:17:00]

Done.

+      gfx::Size(), new ui::ViewAndroid(jview_android_delegate));
+
+  ui::WindowAndroid* window =
+        reinterpret_cast<ui::WindowAndroid*>(window_android);
+  DCHECK(window);
+  window->AddChild(web_contents->GetView()->GetNativeView());
+
   ContentViewCoreImpl* view = new ContentViewCoreImpl(
-      env, obj, WebContents::FromJavaWebContents(web_contents),
-      view_android_delegate,
-      reinterpret_cast<ui::WindowAndroid*>(window_android),
-      retained_objects_set);
+      env, obj, web_contents, retained_objects_set);
   return reinterpret_cast<intptr_t>(view);
 }
 
 static ScopedJavaLocalRef<jobject> FromWebContentsAndroid(
     JNIEnv* env,
     const JavaParamRef<jclass>& clazz,
     const JavaParamRef<jobject>& jweb_contents) {
   WebContents* web_contents = WebContents::FromJavaWebContents(jweb_contents);
   if (!web_contents)
     return ScopedJavaLocalRef<jobject>();
 
   ContentViewCore* view = ContentViewCore::FromWebContents(web_contents);
   if (!view)
     return ScopedJavaLocalRef<jobject>();
 
   return view->GetJavaObject();
 }
 
 bool RegisterContentViewCore(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // namespace content