Make ChromotingHost::ui_strings() immutable.

remoting/host/disconnect_window_linux.cc

 // Copyright (c) 2011 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 <gtk/gtk.h>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
+#include "base/string_util.h"
+#include "base/utf_string_conversions.h"
 #include "remoting/host/chromoting_host.h"
 #include "remoting/host/ui_strings.h"
 #include "ui/base/gtk/gtk_signal.h"
 
 namespace {
 // The width in pixels at which the message will wrap. Given that the message
 // contains an un-splittable email address, it's unlikely that a fixed width
 // is going to look aesthetically pleasing in all languages.
 // TODO(jamiewalch): Replace this with a layout that only uses a single line,
 // and which is docked at the top or bottom of the host screen, as in our
 // UI mocks.
 const int kMessageWidth = 300;
 }
 
 namespace remoting {
 
 class DisconnectWindowLinux : public DisconnectWindow {
  public:
   DisconnectWindowLinux();
   virtual ~DisconnectWindowLinux();
 
   virtual void Show(ChromotingHost* host,
                     const std::string& username) OVERRIDE;
   virtual void Hide() OVERRIDE;
 
  private:
   CHROMEGTK_CALLBACK_1(DisconnectWindowLinux, void, OnResponse, int);
 
-  void CreateWindow(UiStrings* ui_strings);
+  void CreateWindow(const UiStrings& ui_strings);
 
   ChromotingHost* host_;
   GtkWidget* disconnect_window_;
   GtkWidget* message_;
 
   DISALLOW_COPY_AND_ASSIGN(DisconnectWindowLinux);
 };
 
 DisconnectWindowLinux::DisconnectWindowLinux()
     : host_(NULL),
       disconnect_window_(NULL) {
 }
 
 DisconnectWindowLinux::~DisconnectWindowLinux() {
 }
 
-void DisconnectWindowLinux::CreateWindow(UiStrings* ui_strings) {
+void DisconnectWindowLinux::CreateWindow(const UiStrings& ui_strings) {
   if (disconnect_window_) return;
 
   disconnect_window_ = gtk_dialog_new_with_buttons(
-      ui_strings->product_name.c_str(),
+      UTF16ToUTF8(ui_strings.product_name).c_str(),
       NULL,
       GTK_DIALOG_NO_SEPARATOR,
-      ui_strings->disconnect_button_text_plus_shortcut.c_str(), GTK_RESPONSE_OK,
+      UTF16ToUTF8(ui_strings.disconnect_button_text_plus_shortcut).c_str(),
+      GTK_RESPONSE_OK,
       NULL);
 
   GtkWindow* window = GTK_WINDOW(disconnect_window_);
   gtk_window_set_resizable(window, FALSE);
   // Try to keep the window always visible.
   gtk_window_stick(window);
   gtk_window_set_keep_above(window, TRUE);
   // Utility windows have no minimize button or taskbar presence.
   gtk_window_set_type_hint(window, GDK_WINDOW_TYPE_HINT_UTILITY);
   gtk_window_set_deletable(window, FALSE);
@@ skipping 13 matching lines @@
 
   message_ = gtk_label_new(NULL);
   gtk_widget_set_size_request(message_, kMessageWidth, -1);
   gtk_label_set_line_wrap(GTK_LABEL(message_), true);
   gtk_container_add(GTK_CONTAINER(message_row), message_);
 
   gtk_widget_show_all(content_area);
 }
 
 void DisconnectWindowLinux::Show(ChromotingHost* host,
-                                 const std::string& /* unused */) {
+                                 const std::string& username) {
   host_ = host;
   CreateWindow(host->ui_strings());
-  gtk_label_set_text(GTK_LABEL(message_),
-                     host->ui_strings()->disconnect_message.c_str());
+
+  string16 text = ReplaceStringPlaceholders(
+      host->ui_strings().disconnect_message, UTF8ToUTF16(username), NULL);
+  gtk_label_set_text(GTK_LABEL(message_), UTF16ToUTF8(text).c_str());
   gtk_window_present(GTK_WINDOW(disconnect_window_));
 }
 
 void DisconnectWindowLinux::Hide() {
   if (disconnect_window_) {
     gtk_widget_destroy(disconnect_window_);
     disconnect_window_ = NULL;
   }
 }
 
 void DisconnectWindowLinux::OnResponse(GtkWidget* dialog, int response_id) {
   // |response_id| is ignored, because there is only one button, and pressing
   // it should have the same effect as closing the window (if the window Close
   // button were visible).
   CHECK(host_);
 
   host_->Shutdown(NULL);
   Hide();
 }
 
 DisconnectWindow* DisconnectWindow::Create() {
   return new DisconnectWindowLinux;
 }
 
 }  // namespace remoting