Change PluginInstallImpl to use base::WindowImpl instead of CWindowImpl to re...

webkit/default_plugin/plugin_impl_win.cc

 // Copyright (c) 2006-2009 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 "webkit/default_plugin/plugin_impl_win.h"
 
 #include <shellapi.h>
 
 #include "base/file_util.h"
 #include "base/path_service.h"
@@ skipping 26 matching lines @@
       installation_job_monitor_thread_(
           new PluginInstallationJobMonitorThread()),
       plugin_database_handler_(*this),
       plugin_download_url_for_display_(false) {
 }
 
 PluginInstallerImpl::~PluginInstallerImpl() {
   installation_job_monitor_thread_->Stop();
 
   if (bold_font_)
-    ::DeleteObject(bold_font_);
+    DeleteObject(bold_font_);
 
   if (underline_font_)
-    ::DeleteObject(underline_font_);
+    DeleteObject(underline_font_);
 
   if (activex_installer_) {
     activex_installer_->Cleanup();
     activex_installer_->Release();
   }
 
   if (tooltip_)
-    ::DestroyWindow(tooltip_);
+    DestroyWindow(tooltip_);
 }
 
 bool PluginInstallerImpl::Initialize(HINSTANCE module_handle, NPP instance,
                                      NPMIMEType mime_type, int16 argc,
                                      char* argn[], char* argv[]) {
   DLOG(INFO) << __FUNCTION__ << " Mime Type : " << mime_type;
   DCHECK(instance != NULL);
   DCHECK(module_handle != NULL);
 
   instance_ = instance;
@@ skipping 42 matching lines @@
     plugin_database_handler_.DownloadPluginsFileIfNeeded(plugin_finder_url_);
   }
 
   return true;
 }
 
 void PluginInstallerImpl::Shutdown() {
   if (install_dialog_.IsWindow()) {
     install_dialog_.DestroyWindow();
   }
-  if (IsWindow()) {
-    DestroyWindow();
+  if (IsWindow(hwnd())) {
+    DestroyWindow(hwnd());
   }
 }
 
 void PluginInstallerImpl::NewStream(NPStream* stream) {
   plugin_install_stream_ = stream;
 }
 
 void PluginInstallerImpl::DestroyStream(NPStream* stream, NPError reason) {
   if (stream == plugin_install_stream_)
     plugin_install_stream_ = NULL;
@@ skipping 28 matching lines @@
 }
 
 void PluginInstallerImpl::ClearDisplay() {
   enable_click_ = false;
   command_.clear();
   optional_additional_message_.clear();
   get_plugin_link_message_.clear();
 }
 
 void PluginInstallerImpl::RefreshDisplay() {
-  if (!IsWindow())
+  if (!IsWindow(hwnd()))
     return;
   UpdateToolTip();
 
-  InvalidateRect(NULL, TRUE);
-  UpdateWindow();
+  InvalidateRect(hwnd(), NULL, TRUE);
+  UpdateWindow(hwnd());
 }
 
 bool PluginInstallerImpl::CreateToolTip() {
   DWORD ex_styles = IsRTLLayout() ? WS_EX_LAYOUTRTL : 0;
   tooltip_ = CreateWindowEx(ex_styles, TOOLTIPS_CLASS, NULL,
                             WS_POPUP | TTS_ALWAYSTIP,
                             CW_USEDEFAULT, CW_USEDEFAULT,
                             CW_USEDEFAULT, CW_USEDEFAULT,
-                            m_hWnd, NULL, NULL, NULL);
+                            hwnd(), NULL, NULL, NULL);
  if (!tooltip_)
    return false;
 
   // Associate the ToolTip with the tool.
   TOOLINFO tool_info = {0};
   tool_info.cbSize = sizeof(tool_info);
-  tool_info.hwnd = m_hWnd;
+  tool_info.hwnd = hwnd();
   tool_info.uFlags = TTF_IDISHWND | TTF_SUBCLASS;
-  tool_info.uId = reinterpret_cast<UINT_PTR>(m_hWnd);
+  tool_info.uId = reinterpret_cast<UINT_PTR>(hwnd());
   tool_info.lpszText = NULL;
   SendMessage(tooltip_, TTM_ADDTOOL, 0, reinterpret_cast<LPARAM>(&tool_info));
   SendMessage(tooltip_, TTM_SETMAXTIPWIDTH, 0, TOOLTIP_MAX_WIDTH);
   return true;
 }
 
 void PluginInstallerImpl::UpdateToolTip() {
   if (tooltip_ == NULL)
     return;
   std::wstring tip = command_;
   if (!optional_additional_message_.empty())
     tip += std::wstring(L"\n\r") + optional_additional_message_;
 
   TOOLINFO tool_info = {0};
   tool_info.cbSize = sizeof(tool_info);
-  tool_info.hwnd = m_hWnd;
+  tool_info.hwnd = hwnd();
   tool_info.uFlags = TTF_IDISHWND;
-  tool_info.uId = reinterpret_cast<UINT_PTR>(m_hWnd);
+  tool_info.uId = reinterpret_cast<UINT_PTR>(hwnd());
   tool_info.lpszText = const_cast<LPWSTR>(tip.c_str());
   SendMessage(tooltip_, TTM_UPDATETIPTEXT, 0, (LPARAM)&tool_info);
 }
 
 void PluginInstallerImpl::DisplayAvailablePluginStatus() {
   ClearDisplay();
   enable_click_ = true;
   command_ = ReplaceStringForPossibleEmptyReplacement(
       IDS_DEFAULT_PLUGIN_GET_PLUGIN_MSG,
       IDS_DEFAULT_PLUGIN_GET_PLUGIN_MSG_NO_PLUGIN_NAME,
@@ skipping 86 matching lines @@
     return webkit_glue::GetLocalizedString(messsage_id_without_placeholders);
   } else {
     std::wstring string_with_placeholders =
         webkit_glue::GetLocalizedString(message_id_with_placeholders);
     return ReplaceStringPlaceholders(string_with_placeholders,
                                      replacement_string, NULL);
   }
 }
 
 bool PluginInstallerImpl::SetWindow(HWND parent_window) {
-  if (!::IsWindow(parent_window)) {
+  if (!IsWindow(parent_window)) {
     // No window created yet. Ignore this call.
-    if (!IsWindow())
+    if (!IsWindow(hwnd()))
       return true;
     // Parent window has been destroyed.
     Shutdown();
     return true;
   }
 
   RECT parent_rect = {0};
 
-  if (IsWindow()) {
-    ::GetClientRect(parent_window, &parent_rect);
-    SetWindowPos(NULL, &parent_rect, SWP_SHOWWINDOW);
+  if (IsWindow(hwnd())) {
+    GetClientRect(parent_window, &parent_rect);
+    SetWindowPos(hwnd(), NULL, parent_rect.left, parent_rect.top,
+                 parent_rect.right - parent_rect.left,
+                 parent_rect.bottom - parent_rect.top, SWP_SHOWWINDOW);
     return true;
   }
   // First time in -- no window created by plugin yet.
-  ::GetClientRect(parent_window, &parent_rect);
-  Create(parent_window, parent_rect, NULL, WS_CHILD | WS_BORDER);
-  DCHECK(IsWindow());
-  installation_job_monitor_thread_->set_plugin_window(m_hWnd);
+  GetClientRect(parent_window, &parent_rect);
+  set_window_style(WS_CHILD | WS_BORDER);
+  Init(parent_window, gfx::Rect(parent_rect));
+  DCHECK(IsWindow(hwnd()));
+  installation_job_monitor_thread_->set_plugin_window(hwnd());
 
   CreateToolTip();
   UpdateToolTip();
 
-  UpdateWindow();
-  ShowWindow(SW_SHOW);
+  UpdateWindow(hwnd());
+  ShowWindow(hwnd(), SW_SHOW);
 
   return true;
 }
 
 void PluginInstallerImpl::DownloadPlugin() {
   set_plugin_installer_state(PluginDownloadInitiated);
 
   DLOG(INFO) << "Initiating download for plugin URL "
              << plugin_download_url_.c_str();
 
   DisplayStatus(IDS_DEFAULT_PLUGIN_DOWNLOADING_PLUGIN_MSG);
 
   if (is_activex_) {
     if (activex_installer_ == NULL) {
       CComObject<ActiveXInstaller>::CreateInstance(&activex_installer_);
       activex_installer_->AddRef();
     }
-    activex_installer_->StartDownload(activex_clsid_, activex_codebase_, m_hWnd,
-                                      kActivexInstallResult);
+    activex_installer_->StartDownload(activex_clsid_, activex_codebase_,
+                                      hwnd(), kActivexInstallResult);
   } else {
     if (!plugin_download_url_for_display_) {
-      webkit_glue::DownloadUrl(plugin_download_url_, m_hWnd);
+      webkit_glue::DownloadUrl(plugin_download_url_, hwnd());
     } else {
       default_plugin::g_browser->geturl(instance(),
                                         plugin_download_url_.c_str(),
                                         "_blank");
       set_plugin_installer_state(PluginInstallerLaunchSuccess);
       DisplayStatus(IDS_DEFAULT_PLUGIN_REFRESH_PLUGIN_MSG);
       enable_click_ = true;
       RefreshDisplay();
     }
   }
 }
 
 void PluginInstallerImpl::DownloadCancelled() {
   DisplayAvailablePluginStatus();
 }
 
 LRESULT PluginInstallerImpl::OnEraseBackGround(UINT message, WPARAM wparam,
                                                LPARAM lparam, BOOL& handled) {
   HDC paint_device_context = reinterpret_cast<HDC>(wparam);
   RECT erase_rect = {0};
-  ::GetClipBox(paint_device_context, &erase_rect);
+  GetClipBox(paint_device_context, &erase_rect);
   HBRUSH brush = ::CreateSolidBrush(RGB(252, 235, 162));
   DCHECK(brush);
-  ::FillRect(paint_device_context, &erase_rect, brush);
-  ::DeleteObject(brush);
+  FillRect(paint_device_context, &erase_rect, brush);
+  DeleteObject(brush);
   return 1;
 }
 
 // Use ICU in order to determine whether the locale is right-to-left.
 //
 // TODO(idana) bug# 1246452: there is already code in
 // app/l10n_util.h/cc that uses ICU to determine the locale direction. We don't
 // currently use this code since code in WebKit should not depend on code in
 // Chrome. We can fix this by pulling (at least part of) the l10n_util
 // functionality up into the Base module.
 bool PluginInstallerImpl::IsRTLLayout() const {
   const Locale& locale = Locale::getDefault();
   const char* lang = locale.getLanguage();
 
   // Check only for Arabic and Hebrew languages for now.
   if (strcmp(lang, "ar") == 0 || strcmp(lang, "he") == 0) {
     return true;
   }
   return false;
 }
 
 LRESULT PluginInstallerImpl::OnPaint(UINT message, WPARAM wparam, LPARAM lparam,
                                      BOOL& handled) {
   PAINTSTRUCT paint_struct = {0};
-  BeginPaint(&paint_struct);
+  BeginPaint(hwnd(), &paint_struct);
 
   int save_dc_context = SaveDC(paint_struct.hdc);
   // The drawing order is as below:-
   // 1. The Get plugin link at the top left corner.
   // 2. The plugin icon.
   // 3. The text describing user actions to the right of the icon.
   SIZE get_plugin_link_extents = {0};
   HFONT old_font =
       reinterpret_cast<HFONT>(SelectObject(paint_struct.hdc, regular_font_));
 
   GetTextExtentPoint32(paint_struct.hdc, get_plugin_link_message_.c_str(),
                        static_cast<int>(get_plugin_link_message_.length()),
                        &get_plugin_link_extents);
 
   POINT device_point = {0};
   device_point.x = get_plugin_link_extents.cx;
   device_point.y = get_plugin_link_extents.cy;
   LPtoDP(paint_struct.hdc, &device_point, 1);
 
   RECT text_rect = {0};
   text_rect.left   = 5;
   text_rect.right  = text_rect.left + device_point.x;
   text_rect.top    = 5;
   text_rect.bottom = text_rect.top + device_point.y;
 
   RECT client_rect = {0};
-  GetClientRect(&client_rect);
+  GetClientRect(hwnd(), &client_rect);
 
   int icon_width = GetSystemMetrics(SM_CXICON);
   int icon_height = GetSystemMetrics(SM_CYICON);
 
   int x = (client_rect.right / 2) - icon_width / 2;
   int y = (client_rect.bottom / 2) - icon_height / 2;
 
   DCHECK(icon_);
   DrawIcon(paint_struct.hdc, x, y, icon_);
 
@@ skipping 29 matching lines @@
   // over the plugin window.
   int window_width = client_rect.right - client_rect.left;
   int window_height = client_rect.bottom - client_rect.top;
 
   if ((x_origin + command_extents.cx <= window_width) &&
     (y_origin + command_extents.cy <= window_height)) {
     PaintUserActionInformation(paint_struct.hdc, x_origin, y_origin);
   }
 
   RestoreDC(paint_struct.hdc, save_dc_context);
-  EndPaint(&paint_struct);
+  EndPaint(hwnd(), &paint_struct);
   return 0;
 }
 
 void PluginInstallerImpl::PaintUserActionInformation(HDC paint_dc,
                                                      int x_origin,
                                                      int y_origin) {
   SelectObject(paint_dc, regular_font_);
 
   SIZE command_extents = {0};
   GetTextExtentPoint32(paint_dc, command_.c_str(),
@@ skipping 39 matching lines @@
 
     DrawText(paint_dc, optional_additional_message_.c_str(),
              static_cast<int>(optional_additional_message_.length()),
              &text_rect, DT_CENTER | DT_VCENTER | additional_dt_flags);
   }
 }
 
 void PluginInstallerImpl::ShowInstallDialog() {
   enable_click_ = false;
   install_dialog_.Initialize(this, plugin_name_);
-  install_dialog_.Create(m_hWnd, NULL);
+  install_dialog_.Create(hwnd(), NULL);
   install_dialog_.ShowWindow(SW_SHOW);
 }
 
 LRESULT PluginInstallerImpl::OnLButtonDown(UINT message, WPARAM wparam,
                                            LPARAM lparam, BOOL& handled) {
   if (!enable_click_)
     return 0;
   if (plugin_installer_state() == PluginListDownloaded) {
     ShowInstallDialog();
     NotifyPluginStatus(default_plugin::MISSING_PLUGIN_USER_STARTED_DOWNLOAD);
   } else if (plugin_installer_state_ == PluginInstallerLaunchSuccess) {
     DCHECK(default_plugin::g_browser);
     DCHECK(default_plugin::g_browser->geturl);
     default_plugin::g_browser->geturl(
         instance_,
         "javascript:navigator.plugins.refresh(true)",
         "_self");
     default_plugin::g_browser->geturl(
         instance_,
         "javascript:window.location.reload(true)",
         "_self");
   }
 
   return 0;
 }
 
 LRESULT PluginInstallerImpl::OnSetCursor(UINT message, WPARAM wparam,
                                          LPARAM lparam, BOOL& handled) {
   if (enable_click_) {
-    ::SetCursor(LoadCursor(NULL, MAKEINTRESOURCE(IDC_HAND)));
+    SetCursor(LoadCursor(NULL, MAKEINTRESOURCE(IDC_HAND)));
     return 1;
   }
   handled = FALSE;
   return 0;
 }
 
 LRESULT PluginInstallerImpl::OnRefreshPlugins(UINT message, WPARAM wparam,
                                               LPARAM lparam, BOOL& handled) {
   DCHECK(default_plugin::g_browser);
   DCHECK(default_plugin::g_browser->geturl);
@@ skipping 55 matching lines @@
 
 LRESULT PluginInstallerImpl::OnActiveXInstallResult(UINT message,
                                                     WPARAM wparam,
                                                     LPARAM lparam,
                                                     BOOL& handled) {
   handled = TRUE;
 
   if (SUCCEEDED(wparam)) {
     set_plugin_installer_state(PluginInstallerLaunchSuccess);
     DisplayStatus(IDS_DEFAULT_PLUGIN_REFRESH_PLUGIN_MSG);
-    PostMessage(kRefreshPluginsMessage, 0, 0);
+    PostMessage(hwnd(), kRefreshPluginsMessage, 0, 0);
   } else if ((wparam == INET_E_UNKNOWN_PROTOCOL) ||
              (wparam == HRESULT_FROM_WIN32(ERROR_MOD_NOT_FOUND))) {
     set_plugin_installer_state(PluginDownloadFailed);
     DisplayPluginDownloadFailedStatus();
   } else {
     set_plugin_installer_state(PluginInstallerLaunchFailure);
     DisplayStatus(IDS_DEFAULT_PLUGIN_INSTALLATION_FAILED_MSG);
   }
   return 0;
 }
@@ skipping 101 matching lines @@
   return true;
 }
 
 void PluginInstallerImpl::NotifyPluginStatus(int status) {
   default_plugin::g_browser->getvalue(
     instance_,
     static_cast<NPNVariable>(
         default_plugin::kMissingPluginStatusStart + status),
     NULL);
 }