TabContents -> WebContentsImpl, part 12.

content/browser/web_contents/web_contents_view_win.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_win.h"
 
 #include "base/bind.h"
 #include "content/browser/renderer_host/render_view_host_factory.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_view_win.h"
@@ skipping 44 matching lines @@
   void OnClose() {
   }
 
   BEGIN_MSG_MAP_EX(WebContentsViewWin)
     MSG_WM_CLOSE(OnClose)
   END_MSG_MAP()
 };
 
 }  // namespace namespace
 
-WebContentsViewWin::WebContentsViewWin(TabContents* tab_contents,
+WebContentsViewWin::WebContentsViewWin(WebContentsImpl* web_contents,
                                        WebContentsViewDelegate* delegate)
-    : tab_contents_(tab_contents),
+    : web_contents_(web_contents),
       view_(NULL),
       delegate_(delegate),
       close_tab_after_drag_ends_(false) {
 }
 
 WebContentsViewWin::~WebContentsViewWin() {
   if (IsWindow(hwnd()))
     DestroyWindow(hwnd());
 }
 
 void WebContentsViewWin::CreateView(const gfx::Size& initial_size) {
   initial_size_ = initial_size;
 
   set_window_style(WS_VISIBLE | WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS);
 
   Init(TempParent::Get()->hwnd(), gfx::Rect(initial_size_));
 
   // Remove the root view drop target so we can register our own.
   RevokeDragDrop(GetNativeView());
-  drag_dest_ = new WebDragDest(hwnd(), tab_contents_);
+  drag_dest_ = new WebDragDest(hwnd(), web_contents_);
   if (delegate_.get()) {
     content::WebDragDestDelegate* delegate = delegate_->GetDragDestDelegate();
     if (delegate)
       drag_dest_->set_delegate(delegate);
   }
 }
 
 RenderWidgetHostView* WebContentsViewWin::CreateViewForWidget(
     content::RenderWidgetHost* render_widget_host)  {
   if (render_widget_host->GetView()) {
@@ skipping 12 matching lines @@
   view_->ShowWindow(SW_SHOW);
   view_->SetSize(initial_size_);
   return view_;
 }
 
 gfx::NativeView WebContentsViewWin::GetNativeView() const {
   return hwnd();
 }
 
 gfx::NativeView WebContentsViewWin::GetContentNativeView() const {
-  RenderWidgetHostView* rwhv = tab_contents_->GetRenderWidgetHostView();
+  RenderWidgetHostView* rwhv = web_contents_->GetRenderWidgetHostView();
   return rwhv ? rwhv->GetNativeView() : NULL;
 }
 
 gfx::NativeWindow WebContentsViewWin::GetTopLevelNativeWindow() const {
   return GetParent(GetNativeView());
 }
 
 void WebContentsViewWin::GetContainerBounds(gfx::Rect *out) const {
   // Copied from NativeWidgetWin::GetClientAreaScreenBounds().
   RECT r;
@@ skipping 18 matching lines @@
 
 void WebContentsViewWin::SizeContents(const gfx::Size& size) {
   gfx::Rect bounds;
   GetContainerBounds(&bounds);
   if (bounds.size() != size) {
     SetWindowPos(hwnd(), NULL, 0, 0, size.width(), size.height(),
                  SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOMOVE);
   } else {
     // Our size matches what we want but the renderers size may not match.
     // Pretend we were resized so that the renderers size is updated too.
-    if (tab_contents_->GetInterstitialPage())
-      tab_contents_->GetInterstitialPage()->SetSize(size);
-    RenderWidgetHostView* rwhv = tab_contents_->GetRenderWidgetHostView();
+    if (web_contents_->GetInterstitialPage())
+      web_contents_->GetInterstitialPage()->SetSize(size);
+    RenderWidgetHostView* rwhv = web_contents_->GetRenderWidgetHostView();
     if (rwhv)
       rwhv->SetSize(size);
   }
 }
 
 void WebContentsViewWin::RenderViewCreated(RenderViewHost* host) {
 }
 
 void WebContentsViewWin::Focus() {
-  if (tab_contents_->GetInterstitialPage()) {
-    tab_contents_->GetInterstitialPage()->Focus();
+  if (web_contents_->GetInterstitialPage()) {
+    web_contents_->GetInterstitialPage()->Focus();
     return;
   }
 
   if (delegate_.get() && delegate_->Focus())
     return;
 
-  RenderWidgetHostView* rwhv = tab_contents_->GetRenderWidgetHostView();
+  RenderWidgetHostView* rwhv = web_contents_->GetRenderWidgetHostView();
   if (rwhv)
     rwhv->Focus();
 }
 
 void WebContentsViewWin::SetInitialFocus() {
-  if (tab_contents_->FocusLocationBarByDefault())
-    tab_contents_->SetFocusToLocationBar(false);
+  if (web_contents_->FocusLocationBarByDefault())
+    web_contents_->SetFocusToLocationBar(false);
   else
     Focus();
 }
 
 void WebContentsViewWin::StoreFocus() {
   if (delegate_.get())
     delegate_->StoreFocus();
 }
 
 void WebContentsViewWin::RestoreFocus() {
@@ skipping 23 matching lines @@
 
 void WebContentsViewWin::GetViewBounds(gfx::Rect* out) const {
   RECT r;
   GetWindowRect(hwnd(), &r);
   *out = gfx::Rect(r);
 }
 
 void WebContentsViewWin::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 WebContentsViewWin::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 WebContentsViewWin::CreateNewFullscreenWidget(int route_id) {
-  web_contents_view_helper_.CreateNewWidget(tab_contents_,
+  web_contents_view_helper_.CreateNewWidget(web_contents_,
                                             route_id,
                                             true,
                                             WebKit::WebPopupTypeNone);
 }
 
 void WebContentsViewWin::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 WebContentsViewWin::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 WebContentsViewWin::ShowCreatedFullscreenWidget(int route_id) {
-  web_contents_view_helper_.ShowCreatedWidget(tab_contents_,
+  web_contents_view_helper_.ShowCreatedWidget(web_contents_,
                                               route_id,
                                               true,
                                               gfx::Rect());
 }
 
 void WebContentsViewWin::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 WebContentsViewWin::ShowPopupMenu(const gfx::Rect& bounds,
                                        int item_height,
                                        double item_font_size,
                                        int selected_item,
                                        const std::vector<WebMenuItem>& items,
                                        bool right_aligned) {
   // External popup menus are only used on Mac.
   NOTIMPLEMENTED();
 }
 
 void WebContentsViewWin::StartDragging(const WebDropData& drop_data,
                                        WebKit::WebDragOperationsMask operations,
                                        const SkBitmap& image,
                                        const gfx::Point& image_offset) {
   drag_handler_ = new WebContentsDragWin(
       GetNativeView(),
-      tab_contents_,
+      web_contents_,
       drag_dest_,
       base::Bind(&WebContentsViewWin::EndDragging, base::Unretained(this)));
   drag_handler_->StartDragging(drop_data, operations, image, image_offset);
 }
 
 void WebContentsViewWin::UpdateDragCursor(WebKit::WebDragOperation operation) {
   drag_dest_->set_drag_cursor(operation);
 }
 
 void WebContentsViewWin::GotFocus() {
-  if (tab_contents_->GetDelegate())
-    tab_contents_->GetDelegate()->WebContentsFocused(tab_contents_);
+  if (web_contents_->GetDelegate())
+    web_contents_->GetDelegate()->WebContentsFocused(web_contents_);
 }
 
 void WebContentsViewWin::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);
   }
 }
 
 void WebContentsViewWin::EndDragging() {
   drag_handler_ = NULL;
   if (close_tab_after_drag_ends_) {
     close_tab_timer_.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(0),
                            this, &WebContentsViewWin::CloseTab);
   }
-  tab_contents_->SystemDragEnded();
+  web_contents_->SystemDragEnded();
 }
 
 void WebContentsViewWin::CloseTab() {
-  RenderViewHost* rvh = tab_contents_->GetRenderViewHost();
+  RenderViewHost* rvh = web_contents_->GetRenderViewHost();
   rvh->GetDelegate()->Close(rvh);
 }
 
 LRESULT WebContentsViewWin::OnDestroy(
     UINT message, WPARAM wparam, LPARAM lparam, BOOL& handled) {
   if (drag_dest_.get()) {
     RevokeDragDrop(GetNativeView());
     drag_dest_ = NULL;
   }
   return 0;
 }
 
 LRESULT WebContentsViewWin::OnWindowPosChanged(
     UINT message, WPARAM wparam, LPARAM lparam, BOOL& handled) {
   WINDOWPOS* window_pos = reinterpret_cast<WINDOWPOS*>(lparam);
   if (window_pos->flags & SWP_HIDEWINDOW) {
-    tab_contents_->HideContents();
+    web_contents_->HideContents();
     return 0;
   }
 
-  // The TabContents was shown by a means other than the user selecting a
+  // The WebContents was shown by a means other than the user selecting a
   // Tab, e.g. the window was minimized then restored.
   if (window_pos->flags & SWP_SHOWWINDOW)
-    tab_contents_->ShowContents();
+    web_contents_->ShowContents();
 
   // Unless we were specifically told not to size, cause the renderer to be
   // sized to the new bounds, which forces a repaint. Not required for the
   // simple minimize-restore case described above, for example, since the
   // size hasn't changed.
   if (window_pos->flags & SWP_NOSIZE)
     return 0;
 
   gfx::Size size(window_pos->cx, window_pos->cy);
-  if (tab_contents_->GetInterstitialPage())
-    tab_contents_->GetInterstitialPage()->SetSize(size);
-  RenderWidgetHostView* rwhv = tab_contents_->GetRenderWidgetHostView();
+  if (web_contents_->GetInterstitialPage())
+    web_contents_->GetInterstitialPage()->SetSize(size);
+  RenderWidgetHostView* rwhv = web_contents_->GetRenderWidgetHostView();
   if (rwhv)
     rwhv->SetSize(size);
 
   if (delegate_.get())
     delegate_->SizeChanged(size);
 
   return 0;
 }
 
 LRESULT WebContentsViewWin::OnMouseDown(
     UINT message, WPARAM wparam, LPARAM lparam, BOOL& handled) {
-  // Make sure this TabContents is activated when it is clicked on.
-  if (tab_contents_->GetDelegate())
-    tab_contents_->GetDelegate()->ActivateContents(tab_contents_);
+  // Make sure this WebContents is activated when it is clicked on.
+  if (web_contents_->GetDelegate())
+    web_contents_->GetDelegate()->ActivateContents(web_contents_);
   return 0;
 }
 
 LRESULT WebContentsViewWin::OnMouseMove(
     UINT message, WPARAM wparam, LPARAM lparam, BOOL& handled) {
   // Let our delegate know that the mouse moved (useful for resetting status
   // bubble state).
-  if (tab_contents_->GetDelegate()) {
-    tab_contents_->GetDelegate()->ContentsMouseEvent(
-        tab_contents_, gfx::Screen::GetCursorScreenPoint(), true);
+  if (web_contents_->GetDelegate()) {
+    web_contents_->GetDelegate()->ContentsMouseEvent(
+        web_contents_, gfx::Screen::GetCursorScreenPoint(), true);
   }
   return 0;
 }
 
 LRESULT WebContentsViewWin::OnReflectedMessage(
     UINT msg, WPARAM wparam, LPARAM lparam, BOOL& handled) {
   MSG* message = reinterpret_cast<MSG*>(lparam);
   switch (message->message) {
     case WM_MOUSEWHEEL:
       // This message is reflected from the view() to this window.
       if (GET_KEYSTATE_WPARAM(message->wParam) & MK_CONTROL) {
-        tab_contents_->GetDelegate()->ContentsZoomChange(
+        web_contents_->GetDelegate()->ContentsZoomChange(
             GET_WHEEL_DELTA_WPARAM(message->wParam) > 0);
         return 1;
       }
     break;
   }
   return 0;
 }
 
 LRESULT WebContentsViewWin::OnNCCalcSize(
     UINT message, WPARAM wparam, LPARAM lparam, BOOL& handled) {
@@ skipping 27 matching lines @@
         break;
       case SB_LINEDOWN:
         distance = -WHEEL_DELTA;
         break;
         // TODO(joshia): Handle SB_PAGEUP, SB_PAGEDOWN, SB_THUMBPOSITION,
         // and SB_THUMBTRACK for completeness
       default:
         break;
     }
 
-    tab_contents_->GetDelegate()->ContentsZoomChange(distance > 0);
+    web_contents_->GetDelegate()->ContentsZoomChange(distance > 0);
     return 0;
   }
 
   // Reflect scroll message to the view() to give it a chance
   // to process scrolling.
   SendMessage(GetContentNativeView(), message, wparam, lparam);
   return 0;
 }
 
 LRESULT WebContentsViewWin::OnSize(
@@ skipping 13 matching lines @@
   si.nMin = 1;
   si.nMax = 100;
   si.nPage = 10;
   si.nPos = 50;
 
   ::SetScrollInfo(hwnd(), SB_HORZ, &si, FALSE);
   ::SetScrollInfo(hwnd(), SB_VERT, &si, FALSE);
 
   return 1;
 }