Revert "Revert 146000 - Split out ContentViewCore from ContentView for embedders."

content/browser/renderer_host/render_widget_host_view_android.cc

 // Copyright (c) 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/renderer_host/render_widget_host_view_android.h"
 
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/utf_string_conversions.h"
-#include "content/browser/android/content_view_impl.h"
+#include "content/browser/android/content_view_core_impl.h"
 #include "content/browser/gpu/gpu_surface_tracker.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/common/android/device_info.h"
 #include "content/common/view_messages.h"
 
 namespace content {
 
 RenderWidgetHostViewAndroid::RenderWidgetHostViewAndroid(
     RenderWidgetHostImpl* widget_host,
-    ContentViewImpl* content_view)
+    ContentViewCoreImpl* content_view_core)
     : host_(widget_host),
-      // ContentViewImpl represents the native side of the Java ContentView.
-      // It being NULL means that it is not attached to the View system yet,
-      // so we treat it as hidden.
-      is_hidden_(!content_view),
-      content_view_(content_view) {
+      // ContentViewCoreImpl represents the native side of the Java
+      // ContentViewCore.  It being NULL means that it is not attached to the
+      // View system yet, so we treat it as hidden.
+      is_hidden_(!content_view_core),
+      content_view_core_(content_view_core) {
   host_->SetView(this);
   // RenderWidgetHost is initialized as visible. If is_hidden_ is true, tell
   // RenderWidgetHost to hide.
   if (is_hidden_)
     host_->WasHidden();
 }
 
 RenderWidgetHostViewAndroid::~RenderWidgetHostViewAndroid() {
 }
 
@@ skipping 48 matching lines @@
 }
 
 void RenderWidgetHostViewAndroid::SetBounds(const gfx::Rect& rect) {
   if (rect.origin().x() || rect.origin().y()) {
     VLOG(0) << "SetBounds not implemented for (x,y)!=(0,0)";
   }
   SetSize(rect.size());
 }
 
 gfx::NativeView RenderWidgetHostViewAndroid::GetNativeView() const {
-  return content_view_;
+  return content_view_core_;
 }
 
 gfx::NativeViewId RenderWidgetHostViewAndroid::GetNativeViewId() const {
   return reinterpret_cast<gfx::NativeViewId>(
       const_cast<RenderWidgetHostViewAndroid*>(this));
 }
 
 gfx::NativeViewAccessible
 RenderWidgetHostViewAndroid::GetNativeViewAccessible() {
   NOTIMPLEMENTED();
@@ skipping 13 matching lines @@
 }
 
 void RenderWidgetHostViewAndroid::Blur() {
   host_->Send(new ViewMsg_ExecuteEditCommand(
       host_->GetRoutingID(), "Unselect", ""));
   host_->SetInputMethodActive(false);
   host_->Blur();
 }
 
 bool RenderWidgetHostViewAndroid::HasFocus() const {
-  if (!content_view_)
-    return false;  // ContentView not created yet.
+  if (!content_view_core_)
+    return false;  // ContentViewCore not created yet.
 
-  return content_view_->HasFocus();
+  return content_view_core_->HasFocus();
 }
 
 bool RenderWidgetHostViewAndroid::IsSurfaceAvailableForCopy() const {
   NOTIMPLEMENTED();
   return false;
 }
 
 void RenderWidgetHostViewAndroid::Show() {
   // nothing to do
 }
 
 void RenderWidgetHostViewAndroid::Hide() {
   // nothing to do
 }
 
 bool RenderWidgetHostViewAndroid::IsShowing() {
   return !is_hidden_;
 }
 
 gfx::Rect RenderWidgetHostViewAndroid::GetViewBounds() const {
-  if (content_view_) {
-    return content_view_->GetBounds();
+  if (content_view_core_) {
+    return content_view_core_->GetBounds();
   } else {
-    // The ContentView has not been created yet. This only happens when
+    // The ContentViewCore has not been created yet. This only happens when
     // renderer asks for creating new window, for example,
     // javascript window.open().
     return gfx::Rect(0, 0, 0, 0);
   }
 }
 
 void RenderWidgetHostViewAndroid::UpdateCursor(const WebCursor& cursor) {
   // There are no cursors on Android.
 }
 
@@ skipping 20 matching lines @@
     const std::vector<gfx::Rect>& copy_rects) {
   NOTIMPLEMENTED();
 }
 
 void RenderWidgetHostViewAndroid::RenderViewGone(
     base::TerminationStatus status, int error_code) {
   Destroy();
 }
 
 void RenderWidgetHostViewAndroid::Destroy() {
-  content_view_ = NULL;
+  content_view_core_ = NULL;
 
   // The RenderWidgetHost's destruction led here, so don't call it.
   host_ = NULL;
 
   delete this;
 }
 
 void RenderWidgetHostViewAndroid::SetTooltipText(
     const string16& tooltip_text) {
   // Tooltips don't makes sense on Android.
 }
 
 void RenderWidgetHostViewAndroid::SelectionChanged(const string16& text,
                                                    size_t offset,
                                                    const ui::Range& range) {
   RenderWidgetHostViewBase::SelectionChanged(text, offset, range);
 
-  if (text.empty() || range.is_empty() || !content_view_)
+  if (text.empty() || range.is_empty() || !content_view_core_)
     return;
   size_t pos = range.GetMin() - offset;
   size_t n = range.length();
 
   DCHECK(pos + n <= text.length()) << "The text can not fully cover range.";
   if (pos >= text.length()) {
     NOTREACHED() << "The text can not cover range.";
     return;
   }
 
   std::string utf8_selection = UTF16ToUTF8(text.substr(pos, n));
 
-  content_view_->OnSelectionChanged(utf8_selection);
+  content_view_core_->OnSelectionChanged(utf8_selection);
 }
 
 BackingStore* RenderWidgetHostViewAndroid::AllocBackingStore(
     const gfx::Size& size) {
   NOTIMPLEMENTED();
   return NULL;
 }
 
 void RenderWidgetHostViewAndroid::SetBackground(const SkBitmap& background) {
   RenderWidgetHostViewBase::SetBackground(background);
   host_->Send(new ViewMsg_SetBackground(host_->GetRoutingID(), background));
 }
 
 void RenderWidgetHostViewAndroid::CopyFromCompositingSurface(
       const gfx::Size& size,
       skia::PlatformCanvas* output,
       base::Callback<void(bool)> callback) {
   NOTIMPLEMENTED();
   callback.Run(false);
 }
 
 void RenderWidgetHostViewAndroid::OnAcceleratedCompositingStateChange() {
   const bool activated = host_->is_accelerated_compositing_active();
-  if (content_view_)
-    content_view_->OnAcceleratedCompositingStateChange(this, activated, false);
+  if (content_view_core_)
+    content_view_core_->OnAcceleratedCompositingStateChange(
+        this, activated, false);
 }
 
 void RenderWidgetHostViewAndroid::AcceleratedSurfaceBuffersSwapped(
     const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params,
     int gpu_host_id) {
   NOTREACHED();
 }
 
 void RenderWidgetHostViewAndroid::AcceleratedSurfacePostSubBuffer(
     const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params,
     int gpu_host_id) {
   NOTREACHED();
 }
 
 void RenderWidgetHostViewAndroid::AcceleratedSurfaceSuspend() {
   NOTREACHED();
 }
 
 bool RenderWidgetHostViewAndroid::HasAcceleratedSurface(
     const gfx::Size& desired_size) {
   NOTREACHED();
   return false;
 }
 
 void RenderWidgetHostViewAndroid::StartContentIntent(
     const GURL& content_url) {
-  if (content_view_)
-    content_view_->StartContentIntent(content_url);
+  if (content_view_core_)
+    content_view_core_->StartContentIntent(content_url);
 }
 
 gfx::GLSurfaceHandle RenderWidgetHostViewAndroid::GetCompositingSurface() {
   // On Android, we cannot generate a window handle that can be passed to the
   // GPU process through the native side. Instead, we send the surface handle
   // through Binder after the compositing context has been created.
   return gfx::GLSurfaceHandle(gfx::kNullPluginWindow, true);
 }
 
 void RenderWidgetHostViewAndroid::GetScreenInfo(WebKit::WebScreenInfo* result) {
@@ skipping 29 matching lines @@
 
 bool RenderWidgetHostViewAndroid::LockMouse() {
   NOTIMPLEMENTED();
   return false;
 }
 
 void RenderWidgetHostViewAndroid::UnlockMouse() {
   NOTIMPLEMENTED();
 }
 
-void RenderWidgetHostViewAndroid::SetContentView(
-    ContentViewImpl* content_view) {
-  content_view_ = content_view;
+void RenderWidgetHostViewAndroid::SetContentViewCore(
+    ContentViewCoreImpl* content_view_core) {
+  content_view_core_ = content_view_core;
   if (host_) {
     GpuSurfaceTracker::Get()->SetSurfaceHandle(
-        host_->surface_id(), content_view_ ?
+        host_->surface_id(), content_view_core_ ?
             GetCompositingSurface() : gfx::GLSurfaceHandle());
   }
 }
 
 // static
 void RenderWidgetHostViewPort::GetDefaultScreenInfo(
     ::WebKit::WebScreenInfo* results) {
   DeviceInfo info;
   const int width = info.GetWidth();
   const int height = info.GetHeight();
@@ skipping 11 matching lines @@
 // RenderWidgetHostView, public:
 
 // static
 RenderWidgetHostView*
 RenderWidgetHostView::CreateViewForWidget(RenderWidgetHost* widget) {
   RenderWidgetHostImpl* rwhi = RenderWidgetHostImpl::From(widget);
   return new RenderWidgetHostViewAndroid(rwhi, NULL);
 }
 
 } // namespace content