WebContentsView became more than just an interface with 48103 (r12483). If we...

chrome/browser/tab_contents/web_contents_view_win.cc

 // Copyright (c) 2006-2008 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 "chrome/browser/tab_contents/web_contents_view_win.h"
 
 #include <windows.h>
 
 #include "chrome/browser/bookmarks/bookmark_drag_data.h"
 #include "chrome/browser/browser.h"  // TODO(beng): this dependency is awful.
@@ skipping 49 matching lines @@
 WebContentsViewWin::~WebContentsViewWin() {
   // Makes sure to remove any stored view we may still have in the ViewStorage.
   //
   // It is possible the view went away before us, so we only do this if the
   // view is registered.
   views::ViewStorage* view_storage = views::ViewStorage::GetSharedInstance();
   if (view_storage->RetrieveView(last_focused_view_storage_id_) != NULL)
     view_storage->RemoveView(last_focused_view_storage_id_);
 }
 
-WebContents* WebContentsViewWin::GetWebContents() {
-  return web_contents_;
-}
-
 void WebContentsViewWin::CreateView() {
   set_delete_on_destroy(false);
   // Since we create these windows parented to the desktop window initially, we
   // don't want to create them initially visible.
   set_window_style(WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS);
   WidgetWin::Init(GetDesktopWindow(), gfx::Rect(), false);
 
   // Remove the root view drop target so we can register our own.
   RevokeDragDrop(GetNativeView());
-  drop_target_ = new WebDropTarget(GetNativeView(), web_contents_);
+  drop_target_ = new WebDropTarget(GetNativeView(), web_contents());
 }
 
 RenderWidgetHostView* WebContentsViewWin::CreateViewForWidget(
     RenderWidgetHost* render_widget_host) {
   DCHECK(!render_widget_host->view());
   RenderWidgetHostViewWin* view =
       new RenderWidgetHostViewWin(render_widget_host);
   view->Create(GetNativeView());
   view->ShowWindow(SW_SHOW);
   return view;
 }
 
 gfx::NativeView WebContentsViewWin::GetNativeView() const {
   return WidgetWin::GetNativeView();
 }
 
 gfx::NativeView WebContentsViewWin::GetContentNativeView() const {
-  if (!web_contents_->render_widget_host_view())
+  if (!web_contents()->render_widget_host_view())
     return NULL;
-  return web_contents_->render_widget_host_view()->GetPluginNativeView();
+  return web_contents()->render_widget_host_view()->GetPluginNativeView();
 }
 
 gfx::NativeWindow WebContentsViewWin::GetTopLevelNativeWindow() const {
   return ::GetAncestor(GetNativeView(), GA_ROOT);
 }
 
 void WebContentsViewWin::GetContainerBounds(gfx::Rect* out) const {
   GetBounds(out, false);
 }
 
@@ skipping 26 matching lines @@
       // but we do want to allow them to be added to the bookmarks bar
       // (bookmarklets).
       BookmarkDragData::Element bm_elt;
       bm_elt.is_url = true;
       bm_elt.url = drop_data.url;
       bm_elt.title = drop_data.url_title;
 
       BookmarkDragData bm_drag_data;
       bm_drag_data.elements.push_back(bm_elt);
 
-      bm_drag_data.Write(web_contents_->profile(), data);
+      bm_drag_data.Write(web_contents()->profile(), data);
     } else {
       data->SetURL(drop_data.url, drop_data.url_title);
     }
   }
   if (!drop_data.plain_text.empty())
     data->SetString(drop_data.plain_text);
 
   scoped_refptr<WebDragSource> drag_source(
-      new WebDragSource(GetNativeView(), web_contents_->render_view_host()));
+      new WebDragSource(GetNativeView(), web_contents()->render_view_host()));
 
   DWORD effects;
 
   // We need to enable recursive tasks on the message loop so we can get
   // updates while in the system DoDragDrop loop.
   bool old_state = MessageLoop::current()->NestableTasksAllowed();
   MessageLoop::current()->SetNestableTasksAllowed(true);
   DoDragDrop(data, drag_source, DROPEFFECT_COPY | DROPEFFECT_LINK, &effects);
   MessageLoop::current()->SetNestableTasksAllowed(old_state);
 
-  if (web_contents_->render_view_host())
-    web_contents_->render_view_host()->DragSourceSystemDragEnded();
+  if (web_contents()->render_view_host())
+    web_contents()->render_view_host()->DragSourceSystemDragEnded();
 }
 
 void WebContentsViewWin::OnContentsDestroy() {
   // TODO(brettw) this seems like maybe it can be moved into OnDestroy and this
   // function can be deleted? If you're adding more here, consider whether it
   // can be moved into OnDestroy which is a Windows message handler as the
   // window is being torn down.
 
   // When a tab is closed all its child plugin windows are destroyed
   // automatically. This happens before plugins get any notification that its
@@ skipping 18 matching lines @@
   }
 }
 
 void WebContentsViewWin::SetPageTitle(const std::wstring& title) {
   if (GetNativeView()) {
     // It's possible to get this after the hwnd has been destroyed.
     ::SetWindowText(GetNativeView(), title.c_str());
     // TODO(brettw) this call seems messy the way it reaches into the widget
     // view, and I'm not sure it's necessary. Maybe we should just remove it.
     ::SetWindowText(
-        web_contents_->render_widget_host_view()->GetPluginNativeView(),
+        web_contents()->render_widget_host_view()->GetPluginNativeView(),
         title.c_str());
   }
 }
 
 void WebContentsViewWin::Invalidate() {
   // Note that it's possible to get this message after the window was destroyed.
   if (::IsWindow(GetNativeView()))
     InvalidateRect(GetNativeView(), NULL, FALSE);
 }
 
 void WebContentsViewWin::SizeContents(const gfx::Size& size) {
   // TODO(brettw) this is a hack and should be removed. See web_contents_view.h.
   WasSized(size);
 }
 
 void WebContentsViewWin::SetInitialFocus() {
-  if (web_contents_->FocusLocationBarByDefault())
-    web_contents_->delegate()->SetFocusToLocationBar();
+  if (web_contents()->FocusLocationBarByDefault())
+    web_contents()->delegate()->SetFocusToLocationBar();
   else
     ::SetFocus(GetNativeView());
 }
 
 void WebContentsViewWin::StoreFocus() {
   views::ViewStorage* view_storage = views::ViewStorage::GetSharedInstance();
 
   if (view_storage->RetrieveView(last_focused_view_storage_id_) != NULL)
     view_storage->RemoveView(last_focused_view_storage_id_);
 
@@ skipping 109 matching lines @@
 
   // Any unhandled keyboard/character messages should be defproced.
   // This allows stuff like Alt+F4, etc to work correctly.
   DefWindowProc(event.os_event.hwnd,
                 event.os_event.message,
                 event.os_event.wParam,
                 event.os_event.lParam);
 }
 
 void WebContentsViewWin::ShowContextMenu(const ContextMenuParams& params) {
-  RenderViewContextMenuWin menu(web_contents_,
+  RenderViewContextMenuWin menu(web_contents(),
                                 params,
                                 GetNativeView());
 
   POINT screen_pt = { params.x, params.y };
   MapWindowPoints(GetNativeView(), HWND_DESKTOP, &screen_pt, 1);
 
   // Enable recursive tasks on the message loop so we can get updates while
   // the context menu is being displayed.
   bool old_state = MessageLoop::current()->NestableTasksAllowed();
   MessageLoop::current()->SetNestableTasksAllowed(true);
   menu.RunMenuAt(screen_pt.x, screen_pt.y);
   MessageLoop::current()->SetNestableTasksAllowed(old_state);
 }
 
 WebContents* WebContentsViewWin::CreateNewWindowInternal(
     int route_id,
     base::WaitableEvent* modal_dialog_event) {
   // Create the new web contents. This will automatically create the new
   // WebContentsView. In the future, we may want to create the view separately.
   WebContents* new_contents =
-      new WebContents(web_contents_->profile(),
-                      web_contents_->GetSiteInstance(),
-                      web_contents_->render_view_factory_,
+      new WebContents(web_contents()->profile(),
+                      web_contents()->GetSiteInstance(),
+                      web_contents()->render_view_factory_,
                       route_id,
                       modal_dialog_event);
-  new_contents->SetupController(web_contents_->profile());
+  new_contents->SetupController(web_contents()->profile());
   WebContentsView* new_view = new_contents->view();
 
   new_view->CreateView();
 
   // TODO(brettw) it seems bogus that we have to call this function on the
   // newly created object and give it one of its own member variables.
   new_view->CreateViewForWidget(new_contents->render_view_host());
   return new_contents;
 }
 
 void WebContentsViewWin::ShowCreatedWindowInternal(
     WebContents* new_web_contents,
     WindowOpenDisposition disposition,
     const gfx::Rect& initial_pos,
     bool user_gesture) {
   if (!new_web_contents->render_widget_host_view() ||
       !new_web_contents->process()->channel()) {
     // The view has gone away or the renderer crashed. Nothing to do.
     return;
   }
 
   // TODO(brettw) this seems bogus to reach into here and initialize the host.
   new_web_contents->render_view_host()->Init();
-  web_contents_->AddNewContents(new_web_contents, disposition, initial_pos,
-                                user_gesture);
+  web_contents()->AddNewContents(new_web_contents, disposition, initial_pos,
+                                 user_gesture);
 }
 
 void WebContentsViewWin::OnHScroll(int scroll_type, short position,
                                    HWND scrollbar) {
   ScrollCommon(WM_HSCROLL, scroll_type, position, scrollbar);
 }
 
 void WebContentsViewWin::OnMouseLeave() {
   // Let our delegate know that the mouse moved (useful for resetting status
   // bubble state).
-  if (web_contents_->delegate())
-    web_contents_->delegate()->ContentsMouseEvent(web_contents_, false);
+  if (web_contents()->delegate())
+    web_contents()->delegate()->ContentsMouseEvent(web_contents(), false);
   SetMsgHandled(FALSE);
 }
 
 LRESULT WebContentsViewWin::OnMouseRange(UINT msg,
                                          WPARAM w_param, LPARAM l_param) {
   switch (msg) {
     case WM_LBUTTONDOWN:
     case WM_MBUTTONDOWN:
     case WM_RBUTTONDOWN: {
       // Make sure this TabContents is activated when it is clicked on.
-      if (web_contents_->delegate())
-        web_contents_->delegate()->ActivateContents(web_contents_);
+      if (web_contents()->delegate())
+        web_contents()->delegate()->ActivateContents(web_contents());
       DownloadRequestManager* drm =
           g_browser_process->download_request_manager();
       if (drm)
-        drm->OnUserGesture(web_contents_);
+        drm->OnUserGesture(web_contents());
       break;
     }
     case WM_MOUSEMOVE:
       // Let our delegate know that the mouse moved (useful for resetting status
       // bubble state).
-      if (web_contents_->delegate()) {
-        web_contents_->delegate()->ContentsMouseEvent(web_contents_, true);
+      if (web_contents()->delegate()) {
+        web_contents()->delegate()->ContentsMouseEvent(web_contents(), true);
       }
       break;
     default:
       break;
   }
 
   return 0;
 }
 
 void WebContentsViewWin::OnPaint(HDC junk_dc) {
-  if (web_contents_->render_view_host() &&
-      !web_contents_->render_view_host()->IsRenderViewLive()) {
+  if (web_contents()->render_view_host() &&
+      !web_contents()->render_view_host()->IsRenderViewLive()) {
     if (!sad_tab_.get())
       sad_tab_.reset(new SadTabView);
     CRect cr;
     GetClientRect(&cr);
     sad_tab_->SetBounds(gfx::Rect(cr));
     ChromeCanvasPaint canvas(GetNativeView(), true);
     sad_tab_->ProcessPaint(&canvas);
     return;
   }
 
@@ skipping 27 matching lines @@
   }
 
   return 0;
 }
 
 void WebContentsViewWin::OnSetFocus(HWND window) {
   // TODO(jcampan): figure out why removing this prevents tabs opened in the
   //                background from properly taking focus.
   // We NULL-check the render_view_host_ here because Windows can send us
   // messages during the destruction process after it has been destroyed.
-  if (web_contents_->render_widget_host_view()) {
+  if (web_contents()->render_widget_host_view()) {
     HWND inner_hwnd =
-        web_contents_->render_widget_host_view()->GetPluginNativeView();
+        web_contents()->render_widget_host_view()->GetPluginNativeView();
     if (::IsWindow(inner_hwnd))
       ::SetFocus(inner_hwnd);
   }
 }
 
 void WebContentsViewWin::OnVScroll(int scroll_type, short position,
                                    HWND scrollbar) {
   ScrollCommon(WM_VSCROLL, scroll_type, position, scrollbar);
 }
 
@@ skipping 52 matching lines @@
   if (!ScrollZoom(scroll_type)) {
     // Reflect scroll message to the view() to give it a chance
     // to process scrolling.
     SendMessage(GetContentNativeView(), message,
                 MAKELONG(scroll_type, position),
                 reinterpret_cast<LPARAM>(scrollbar));
   }
 }
 
 void WebContentsViewWin::WasHidden() {
-  web_contents_->HideContents();
+  web_contents()->HideContents();
 }
 
 void WebContentsViewWin::WasShown() {
-  web_contents_->ShowContents();
+  web_contents()->ShowContents();
 }
 
 void WebContentsViewWin::WasSized(const gfx::Size& size) {
-  if (web_contents_->interstitial_page())
-    web_contents_->interstitial_page()->SetSize(size);
-  if (web_contents_->render_widget_host_view())
-    web_contents_->render_widget_host_view()->SetSize(size);
+  if (web_contents()->interstitial_page())
+    web_contents()->interstitial_page()->SetSize(size);
+  if (web_contents()->render_widget_host_view())
+    web_contents()->render_widget_host_view()->SetSize(size);
 
   // TODO(brettw) this function can probably be moved to this class.
-  web_contents_->RepositionSupressedPopupsToFit(size);
+  web_contents()->RepositionSupressedPopupsToFit(size);
 }
 
 bool WebContentsViewWin::ScrollZoom(int scroll_type) {
   // If ctrl is held, zoom the UI.  There are three issues with this:
   // 1) Should the event be eaten or forwarded to content?  We eat the event,
   //    which is like Firefox and unlike IE.
   // 2) Should wheel up zoom in or out?  We zoom in (increase font size), which
   //    is like IE and Google maps, but unlike Firefox.
   // 3) Should the mouse have to be over the content area?  We zoom as long as
   //    content has focus, although FF and IE require that the mouse is over
@@ skipping 14 matching lines @@
         break;
     }
 
     WheelZoom(distance);
     return true;
   }
   return false;
 }
 
 void WebContentsViewWin::WheelZoom(int distance) {
-  if (web_contents_->delegate()) {
+  if (web_contents()->delegate()) {
     bool zoom_in = distance > 0;
-    web_contents_->delegate()->ContentsZoomChange(zoom_in);
+    web_contents()->delegate()->ContentsZoomChange(zoom_in);
   }
 }