Turned UiStrings into a singleton so that the continue window does not depend on ChromotingHost.

remoting/host/disconnect_window_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 "remoting/host/disconnect_window.h"
 
 #include <windows.h>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
@@ skipping 20 matching lines @@
 
 const wchar_t kShellTrayWindowName[] = L"Shell_TrayWnd";
 const int kWindowBorderRadius = 14;
 
 } // namespace anonymous
 
 namespace remoting {
 
 class DisconnectWindowWin : public DisconnectWindow {
  public:
-  DisconnectWindowWin();
+  explicit DisconnectWindowWin(const UiStrings* ui_strings);
   virtual ~DisconnectWindowWin();
 
   // DisconnectWindow interface.
-  virtual bool Show(const UiStrings& ui_strings,
-                    const base::Closure& disconnect_callback,
+  virtual bool Show(const base::Closure& disconnect_callback,
                     const std::string& username) OVERRIDE;
   virtual void Hide() OVERRIDE;
 
 private:
   static BOOL CALLBACK DialogProc(HWND hwnd, UINT message, WPARAM wparam,
                                   LPARAM lparam);
 
   BOOL OnDialogMessage(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
 
   // Creates the dialog window and registers the disconnect hot key.
-  bool BeginDialog(const UiStrings& ui_strings,
-                   const std::string& username);
+  bool BeginDialog(const std::string& username);
 
   // Closes the dialog, unregisters the hot key and invokes the disconnect
   // callback, if set.
   void EndDialog();
 
   // Trys to position the dialog window above the taskbar.
   void SetDialogPosition();
 
   // Applies localization string and resizes the dialog.
-  bool SetStrings(const UiStrings& strings, const string16& username);
+  bool SetStrings(const string16& username);
 
   base::Closure disconnect_callback_;
   HWND hwnd_;
   bool has_hotkey_;
   base::win::ScopedGDIObject<HPEN> border_pen_;
 
+  // Points to the localized strings.
+  const UiStrings* ui_strings_;
+
   DISALLOW_COPY_AND_ASSIGN(DisconnectWindowWin);
 };
 
 static int GetControlTextWidth(HWND control) {
   RECT rect = {0, 0, 0, 0};
   WCHAR text[256];
   int result = GetWindowText(control, text, arraysize(text));
   if (result) {
     base::win::ScopedGetDC dc(control);
     base::win::ScopedSelectObject font(
         dc, (HFONT)SendMessage(control, WM_GETFONT, 0, 0));
     DrawText(dc, text, -1, &rect, DT_CALCRECT | DT_SINGLELINE);
   }
   return rect.right;
 }
 
-DisconnectWindowWin::DisconnectWindowWin()
+DisconnectWindowWin::DisconnectWindowWin(const UiStrings* ui_strings)
     : hwnd_(NULL),
       has_hotkey_(false),
       border_pen_(CreatePen(PS_SOLID, 5,
-                            RGB(0.13 * 255, 0.69 * 255, 0.11 * 255))) {
+                            RGB(0.13 * 255, 0.69 * 255, 0.11 * 255))),
+      ui_strings_(ui_strings) {
 }
 
 DisconnectWindowWin::~DisconnectWindowWin() {
   Hide();
 }
 
-bool DisconnectWindowWin::Show(const UiStrings& ui_strings,
-                               const base::Closure& disconnect_callback,
+bool DisconnectWindowWin::Show(const base::Closure& disconnect_callback,
                                const std::string& username) {
   DCHECK(disconnect_callback_.is_null());
   DCHECK(!disconnect_callback.is_null());
 
   disconnect_callback_ = disconnect_callback;
 
-  if (BeginDialog(ui_strings, username)) {
+  if (BeginDialog(username)) {
     return true;
   } else {
     Hide();
     return false;
   }
 }
 
 void DisconnectWindowWin::Hide() {
   // Clear the |disconnect_callback_| so it won't be invoked by EndDialog().
   disconnect_callback_.Reset();
@@ skipping 81 matching lines @@
         RoundRect(hdc, rect.left, rect.top, rect.right - 1, rect.bottom - 1,
                   kWindowBorderRadius, kWindowBorderRadius);
       }
       EndPaint(hwnd_, &ps);
       return TRUE;
     }
   }
   return FALSE;
 }
 
-bool DisconnectWindowWin::BeginDialog(const UiStrings& ui_strings,
-                                      const std::string& username) {
+bool DisconnectWindowWin::BeginDialog(const std::string& username) {
   DCHECK(!hwnd_);
 
   // Load the dialog resource so that we can modify the RTL flags if necessary.
   HMODULE module = base::GetModuleFromAddress(&DialogProc);
   HRSRC dialog_resource =
       FindResource(module, MAKEINTRESOURCE(IDD_DISCONNECT), RT_DIALOG);
   if (!dialog_resource)
     return false;
 
   HGLOBAL dialog_template = LoadResource(module, dialog_resource);
   if (!dialog_template)
     return false;
 
   DLGTEMPLATE* dialog_pointer =
       reinterpret_cast<DLGTEMPLATE*>(LockResource(dialog_template));
   if (!dialog_pointer)
     return false;
 
   // The actual resource type is DLGTEMPLATEEX, but this is not defined in any
   // standard headers, so we treat it as a generic pointer and manipulate the
   // correct offsets explicitly.
   scoped_array<unsigned char> rtl_dialog_template;
-  if (ui_strings.direction == UiStrings::RTL) {
+  if (ui_strings_->direction == UiStrings::RTL) {
     unsigned long dialog_template_size =
         SizeofResource(module, dialog_resource);
     rtl_dialog_template.reset(new unsigned char[dialog_template_size]);
     memcpy(rtl_dialog_template.get(), dialog_pointer, dialog_template_size);
     DWORD* rtl_dwords = reinterpret_cast<DWORD*>(rtl_dialog_template.get());
     rtl_dwords[2] |= (WS_EX_LAYOUTRTL | WS_EX_RTLREADING);
     dialog_pointer = reinterpret_cast<DLGTEMPLATE*>(rtl_dwords);
   }
 
   hwnd_ = CreateDialogIndirectParam(module, dialog_pointer, NULL,
                                     DialogProc, reinterpret_cast<LPARAM>(this));
   if (!hwnd_)
     return false;
 
   // Set up handler for Ctrl-Alt-Esc shortcut.
   if (!has_hotkey_ && RegisterHotKey(hwnd_, DISCONNECT_HOTKEY_ID,
                                      MOD_ALT | MOD_CONTROL, VK_ESCAPE)) {
     has_hotkey_ = true;
   }
 
-  if (!SetStrings(ui_strings, UTF8ToUTF16(username)))
+  if (!SetStrings(UTF8ToUTF16(username)))
     return false;
 
   SetDialogPosition();
   ShowWindow(hwnd_, SW_SHOW);
   return IsWindowVisible(hwnd_) != FALSE;
 }
 
 void DisconnectWindowWin::EndDialog() {
   if (has_hotkey_) {
     UnregisterHotKey(hwnd_, DISCONNECT_HOTKEY_ID);
@@ skipping 22 matching lines @@
       GetWindowRect(hwnd_, &window_rect)) {
     int window_width = window_rect.right - window_rect.left;
     int window_height = window_rect.bottom - window_rect.top;
     int top = monitor_info.rcWork.bottom - window_height;
     int left = (monitor_info.rcWork.right + monitor_info.rcWork.left -
         window_width) / 2;
     SetWindowPos(hwnd_, NULL, left, top, 0, 0, SWP_NOSIZE | SWP_NOZORDER);
   }
 }
 
-bool DisconnectWindowWin::SetStrings(const UiStrings& ui_strings,
-                                     const string16& username) {
-  if (!SetWindowText(hwnd_, ui_strings.product_name.c_str()))
+bool DisconnectWindowWin::SetStrings(const string16& username) {
+  if (!SetWindowText(hwnd_, ui_strings_->product_name.c_str()))
     return false;
 
   // Localize the disconnect button text and measure length of the old and new
   // labels.
   HWND disconnect_button = GetDlgItem(hwnd_, IDC_DISCONNECT);
   if (!disconnect_button)
     return false;
   int button_old_required_width = GetControlTextWidth(disconnect_button);
   if (!SetWindowText(disconnect_button,
-                     ui_strings.disconnect_button_text.c_str())) {
+                     ui_strings_->disconnect_button_text.c_str())) {
     return false;
   }
   int button_new_required_width = GetControlTextWidth(disconnect_button);
   int button_width_delta =
       button_new_required_width - button_old_required_width;
 
   // Format and truncate "Your desktop is shared with ..." message.
-  string16 text = ReplaceStringPlaceholders(ui_strings.disconnect_message,
+  string16 text = ReplaceStringPlaceholders(ui_strings_->disconnect_message,
                                             username, NULL);
   if (text.length() > kMaxSharingWithTextLength)
     text.erase(kMaxSharingWithTextLength);
 
   // Set localized and truncated "Your desktop is shared with ..." message and
   // measure length of the old and new text.
   HWND sharing_with_label = GetDlgItem(hwnd_, IDC_DISCONNECT_SHARINGWITH);
   if (!sharing_with_label)
     return false;
   int label_old_required_width = GetControlTextWidth(sharing_with_label);
@@ skipping 48 matching lines @@
   HRGN rgn = CreateRoundRectRgn(0, 0, width, height, kWindowBorderRadius,
                                 kWindowBorderRadius);
   if (!rgn)
     return false;
   if (!SetWindowRgn(hwnd_, rgn, TRUE))
     return false;
 
   return true;
 }
 
-scoped_ptr<DisconnectWindow> DisconnectWindow::Create() {
-  return scoped_ptr<DisconnectWindow>(new DisconnectWindowWin());
+scoped_ptr<DisconnectWindow> DisconnectWindow::Create(
+    const UiStrings* ui_strings) {
+  return scoped_ptr<DisconnectWindow>(new DisconnectWindowWin(ui_strings));
 }
 
 }  // namespace remoting