TabContents -> WebContentsImpl, part 12.

content/browser/web_contents/web_contents_view_aura.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/web_contents/web_contents_view_aura.h"
 
 #include "base/utf_string_conversions.h"
 #include "content/browser/renderer_host/render_view_host_factory.h"
 #include "content/browser/web_contents/interstitial_page_impl.h"
 #include "content/browser/web_contents/web_contents_impl.h"
@@ skipping 16 matching lines @@
 #include "ui/gfx/compositor/layer.h"
 #include "ui/gfx/screen.h"
 #include "webkit/glue/webdropdata.h"
 
 namespace {
 
 // Listens to all mouse drag events during a drag and drop and sends them to
 // the renderer.
 class WebDragSourceAura : public MessageLoopForUI::Observer {
  public:
-  explicit WebDragSourceAura(TabContents* contents)
+  explicit WebDragSourceAura(WebContentsImpl* contents)
       : contents_(contents) {
     MessageLoopForUI::current()->AddObserver(this);
   }
 
   virtual ~WebDragSourceAura() {
     MessageLoopForUI::current()->RemoveObserver(this);
   }
 
   // MessageLoop::Observer implementation:
   virtual base::EventStatus WillProcessEvent(
@@ skipping 16 matching lines @@
               screen_loc.x(), screen_loc.y());
         }
         break;
       default:
         break;
     }
   }
 
 
  private:
-  TabContents* contents_;
+  WebContentsImpl* contents_;
 
   DISALLOW_COPY_AND_ASSIGN(WebDragSourceAura);
 };
 
 // Utility to fill a ui::OSExchangeDataProviderAura object from WebDropData.
 void PrepareDragData(const WebDropData& drop_data,
                      ui::OSExchangeDataProviderAura* provider) {
   if (!drop_data.plain_text.empty())
     provider->SetString(drop_data.plain_text);
   if (drop_data.url.is_valid())
@@ skipping 71 matching lines @@
   return (WebKit::WebDragOperationsMask) web_drag_op;
 }
 
 }  // namespace
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // WebContentsViewAura, public:
 
 WebContentsViewAura::WebContentsViewAura(
-    TabContents* tab_contents,
+    WebContentsImpl* web_contents,
     content::WebContentsViewDelegate* delegate)
-    : tab_contents_(tab_contents),
+    : web_contents_(web_contents),
       view_(NULL),
       delegate_(delegate),
       current_drag_op_(WebKit::WebDragOperationNone),
       close_tab_after_drag_ends_(false) {
 }
 
 WebContentsViewAura::~WebContentsViewAura() {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WebContentsViewAura, private:
 
 void WebContentsViewAura::SizeChangedCommon(const gfx::Size& size) {
-  if (tab_contents_->GetInterstitialPage())
-    tab_contents_->GetInterstitialPage()->SetSize(size);
+  if (web_contents_->GetInterstitialPage())
+    web_contents_->GetInterstitialPage()->SetSize(size);
   content::RenderWidgetHostView* rwhv =
-      tab_contents_->GetRenderWidgetHostView();
+      web_contents_->GetRenderWidgetHostView();
   if (rwhv)
     rwhv->SetSize(size);
 }
 
 void WebContentsViewAura::EndDrag(WebKit::WebDragOperationsMask ops) {
   aura::RootWindow* root_window = GetNativeView()->GetRootWindow();
   gfx::Point screen_loc = root_window->last_mouse_location();
   gfx::Point client_loc = screen_loc;
-  content::RenderViewHost* rvh = tab_contents_->GetRenderViewHost();
+  content::RenderViewHost* rvh = web_contents_->GetRenderViewHost();
   aura::Window* window = rvh->GetView()->GetNativeView();
   aura::Window::ConvertPointToWindow(root_window, window, &client_loc);
   rvh->DragSourceEndedAt(client_loc.x(), client_loc.y(), screen_loc.x(),
       screen_loc.y(), ops);
 }
 
 content::WebDragDestDelegate* WebContentsViewAura::GetDragDestDelegate() {
   return delegate_.get() ? delegate_->GetDragDestDelegate() : NULL;
 }
 
@@ skipping 71 matching lines @@
     // Pretend we were resized so that the renderers size is updated too.
     SizeChangedCommon(size);
 
   }
 }
 
 void WebContentsViewAura::RenderViewCreated(content::RenderViewHost* host) {
 }
 
 void WebContentsViewAura::Focus() {
-  if (tab_contents_->GetInterstitialPage()) {
-    tab_contents_->GetInterstitialPage()->Focus();
+  if (web_contents_->GetInterstitialPage()) {
+    web_contents_->GetInterstitialPage()->Focus();
     return;
   }
 
   if (delegate_.get() && delegate_->Focus())
     return;
 
   content::RenderWidgetHostView* rwhv =
-      tab_contents_->GetRenderWidgetHostView();
+      web_contents_->GetRenderWidgetHostView();
   if (rwhv)
     rwhv->Focus();
 }
 
 void WebContentsViewAura::SetInitialFocus() {
-  if (tab_contents_->FocusLocationBarByDefault())
-    tab_contents_->SetFocusToLocationBar(false);
+  if (web_contents_->FocusLocationBarByDefault())
+    web_contents_->SetFocusToLocationBar(false);
   else
     Focus();
 }
 
 void WebContentsViewAura::StoreFocus() {
   if (delegate_.get())
     delegate_->StoreFocus();
 }
 
 void WebContentsViewAura::RestoreFocus() {
@@ skipping 30 matching lines @@
 void WebContentsViewAura::GetViewBounds(gfx::Rect* out) const {
   *out = window_->GetScreenBounds();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WebContentsViewAura, RenderViewHostDelegate::View implementation:
 
 void WebContentsViewAura::CreateNewWindow(
     int route_id,
     const ViewHostMsg_CreateWindow_Params& params) {
-  web_contents_view_helper_.CreateNewWindow(tab_contents_, route_id, params);
+  web_contents_view_helper_.CreateNewWindow(web_contents_, route_id, params);
 }
 
 void WebContentsViewAura::CreateNewWidget(int route_id,
                                           WebKit::WebPopupType popup_type) {
-  web_contents_view_helper_.CreateNewWidget(tab_contents_,
+  web_contents_view_helper_.CreateNewWidget(web_contents_,
                                             route_id,
                                             false,
                                             popup_type);
 }
 
 void WebContentsViewAura::CreateNewFullscreenWidget(int route_id) {
-  web_contents_view_helper_.CreateNewWidget(tab_contents_,
+  web_contents_view_helper_.CreateNewWidget(web_contents_,
                                             route_id,
                                             true,
                                             WebKit::WebPopupTypeNone);
 }
 
 void WebContentsViewAura::ShowCreatedWindow(int route_id,
                                             WindowOpenDisposition disposition,
                                             const gfx::Rect& initial_pos,
                                             bool user_gesture) {
   web_contents_view_helper_.ShowCreatedWindow(
-      tab_contents_, route_id, disposition, initial_pos, user_gesture);
+      web_contents_, route_id, disposition, initial_pos, user_gesture);
 }
 
 void WebContentsViewAura::ShowCreatedWidget(int route_id,
                                             const gfx::Rect& initial_pos) {
-  web_contents_view_helper_.ShowCreatedWidget(tab_contents_,
+  web_contents_view_helper_.ShowCreatedWidget(web_contents_,
                                               route_id,
                                               false,
                                               initial_pos);
 }
 
 void WebContentsViewAura::ShowCreatedFullscreenWidget(int route_id) {
-  web_contents_view_helper_.ShowCreatedWidget(tab_contents_,
+  web_contents_view_helper_.ShowCreatedWidget(web_contents_,
                                               route_id,
                                               true,
                                               gfx::Rect());
 }
 
 void WebContentsViewAura::ShowContextMenu(
     const content::ContextMenuParams& params) {
   // Allow WebContentsDelegates to handle the context menu operation first.
-  if (tab_contents_->GetDelegate() &&
-      tab_contents_->GetDelegate()->HandleContextMenu(params)) {
+  if (web_contents_->GetDelegate() &&
+      web_contents_->GetDelegate()->HandleContextMenu(params)) {
     return;
   }
 
   if (delegate_.get())
     delegate_->ShowContextMenu(params);
 }
 
 void WebContentsViewAura::ShowPopupMenu(const gfx::Rect& bounds,
                                         int item_height,
                                         double item_font_size,
@@ skipping 13 matching lines @@
   if (!aura::client::GetDragDropClient(root_window))
     return;
 
   ui::OSExchangeDataProviderAura* provider = new ui::OSExchangeDataProviderAura;
   PrepareDragData(drop_data, provider);
   if (!image.isNull())
     provider->set_drag_image(image);
   ui::OSExchangeData data(provider);  // takes ownership of |provider|.
 
   scoped_ptr<WebDragSourceAura> drag_source(
-      new WebDragSourceAura(tab_contents_));
+      new WebDragSourceAura(web_contents_));
 
   // We need to enable recursive tasks on the message loop so we can get
   // updates while in the system DoDragDrop loop.
   int result_op = 0;
   {
     // TODO(sad): Avoid using last_mouse_location here, since the drag may not
     // always start from a mouse-event (e.g. a touch or gesture event could
     // initiate the drag). The location information should be carried over from
     // webkit. http://crbug.com/114754
     gfx::Point location(root_window->last_mouse_location());
     location.Offset(-image_offset.x(), -image_offset.y());
     MessageLoop::ScopedNestableTaskAllower allow(MessageLoop::current());
     result_op = aura::client::GetDragDropClient(root_window)->StartDragAndDrop(
         data, location, ConvertFromWeb(operations));
   }
 
   EndDrag(ConvertToWeb(result_op));
-  tab_contents_->GetRenderViewHost()->DragSourceSystemDragEnded();}
+  web_contents_->GetRenderViewHost()->DragSourceSystemDragEnded();}
 
 void WebContentsViewAura::UpdateDragCursor(WebKit::WebDragOperation operation) {
   current_drag_op_ = operation;
 }
 
 void WebContentsViewAura::GotFocus() {
-  if (tab_contents_->GetDelegate())
-    tab_contents_->GetDelegate()->WebContentsFocused(tab_contents_);
+  if (web_contents_->GetDelegate())
+    web_contents_->GetDelegate()->WebContentsFocused(web_contents_);
 }
 
 void WebContentsViewAura::TakeFocus(bool reverse) {
-  if (tab_contents_->GetDelegate() &&
-      !tab_contents_->GetDelegate()->TakeFocus(reverse) &&
+  if (web_contents_->GetDelegate() &&
+      !web_contents_->GetDelegate()->TakeFocus(reverse) &&
       delegate_.get()) {
     delegate_->TakeFocus(reverse);
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WebContentsViewAura, aura::WindowDelegate implementation:
 
 gfx::Size WebContentsViewAura::GetMinimumSize() const {
   return gfx::Size();
@@ skipping 18 matching lines @@
 
 gfx::NativeCursor WebContentsViewAura::GetCursor(const gfx::Point& point) {
   return gfx::kNullCursor;
 }
 
 int WebContentsViewAura::GetNonClientComponent(const gfx::Point& point) const {
   return HTCLIENT;
 }
 
 bool WebContentsViewAura::OnMouseEvent(aura::MouseEvent* event) {
-  if (!tab_contents_->GetDelegate())
+  if (!web_contents_->GetDelegate())
     return false;
 
   switch (event->type()) {
     case ui::ET_MOUSE_PRESSED:
-      tab_contents_->GetDelegate()->ActivateContents(tab_contents_);
+      web_contents_->GetDelegate()->ActivateContents(web_contents_);
       break;
     case ui::ET_MOUSE_MOVED:
-      tab_contents_->GetDelegate()->ContentsMouseEvent(
-          tab_contents_, gfx::Screen::GetCursorScreenPoint(), true);
+      web_contents_->GetDelegate()->ContentsMouseEvent(
+          web_contents_, gfx::Screen::GetCursorScreenPoint(), true);
       break;
     default:
       break;
   }
   return false;
 }
 
 ui::TouchStatus WebContentsViewAura::OnTouchEvent(aura::TouchEvent* event) {
   return ui::TOUCH_STATUS_UNKNOWN;
 }
@@ skipping 14 matching lines @@
 }
 
 void WebContentsViewAura::OnWindowDestroying() {
 }
 
 void WebContentsViewAura::OnWindowDestroyed() {
 }
 
 void WebContentsViewAura::OnWindowVisibilityChanged(bool visible) {
   if (visible)
-    tab_contents_->ShowContents();
+    web_contents_->ShowContents();
   else
-    tab_contents_->HideContents();
+    web_contents_->HideContents();
 }
 ////////////////////////////////////////////////////////////////////////////////
 // WebContentsViewAura, aura::client::DragDropDelegate implementation:
 
 void WebContentsViewAura::OnDragEntered(const aura::DropTargetEvent& event) {
   if (GetDragDestDelegate())
-    GetDragDestDelegate()->DragInitialize(tab_contents_);
+    GetDragDestDelegate()->DragInitialize(web_contents_);
 
   WebDropData drop_data;
   PrepareWebDropData(&drop_data, event.data());
   WebKit::WebDragOperationsMask op = ConvertToWeb(event.source_operations());
 
   gfx::Point screen_pt =
       GetNativeView()->GetRootWindow()->last_mouse_location();
-  tab_contents_->GetRenderViewHost()->DragTargetDragEnter(
+  web_contents_->GetRenderViewHost()->DragTargetDragEnter(
       drop_data, event.location(), screen_pt, op);
 
   if (GetDragDestDelegate()) {
     GetDragDestDelegate()->OnReceiveDragData(event.data());
     GetDragDestDelegate()->OnDragEnter();
   }
 }
 
 int WebContentsViewAura::OnDragUpdated(const aura::DropTargetEvent& event) {
   WebKit::WebDragOperationsMask op = ConvertToWeb(event.source_operations());
   gfx::Point screen_pt =
       GetNativeView()->GetRootWindow()->last_mouse_location();
-  tab_contents_->GetRenderViewHost()->DragTargetDragOver(
+  web_contents_->GetRenderViewHost()->DragTargetDragOver(
       event.location(), screen_pt, op);
 
   if (GetDragDestDelegate())
     GetDragDestDelegate()->OnDragOver();
 
   return ConvertFromWeb(current_drag_op_);
 }
 
 void WebContentsViewAura::OnDragExited() {
-  tab_contents_->GetRenderViewHost()->DragTargetDragLeave();
+  web_contents_->GetRenderViewHost()->DragTargetDragLeave();
   if (GetDragDestDelegate())
     GetDragDestDelegate()->OnDragLeave();
 }
 
 int WebContentsViewAura::OnPerformDrop(const aura::DropTargetEvent& event) {
-  tab_contents_->GetRenderViewHost()->DragTargetDrop(
+  web_contents_->GetRenderViewHost()->DragTargetDrop(
       event.location(),
       GetNativeView()->GetRootWindow()->last_mouse_location());
   if (GetDragDestDelegate())
     GetDragDestDelegate()->OnDrop();
   return current_drag_op_;
 }