Make ChromotingHost::ui_strings() immutable.

remoting/host/plugin/host_script_object.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/plugin/host_script_object.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
+#include "base/sys_string_conversions.h"
 #include "base/threading/platform_thread.h"
+#include "base/utf_string_conversions.h"
 #include "remoting/base/auth_token_util.h"
 #include "remoting/base/util.h"
 #include "remoting/host/chromoting_host.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/desktop_environment.h"
 #include "remoting/host/host_config.h"
 #include "remoting/host/host_key_pair.h"
 #include "remoting/host/in_memory_host_config.h"
 #include "remoting/host/plugin/policy_hack/nat_policy.h"
 #include "remoting/host/register_support_host_request.h"
@@ skipping 322 matching lines @@
 }
 
 void HostNPScriptObject::OnClientAuthenticated(
     remoting::protocol::ConnectionToClient* client) {
   DCHECK_NE(base::PlatformThread::CurrentId(), np_thread_id_);
   client_username_ = client->session()->jid();
   size_t pos = client_username_.find('/');
   if (pos != std::string::npos)
     client_username_.replace(pos, std::string::npos, "");
   LOG(INFO) << "Client " << client_username_ << " connected.";
-  LocalizeStrings();
   OnStateChanged(kConnected);
 }
 
 void HostNPScriptObject::OnClientDisconnected(
     remoting::protocol::ConnectionToClient* client) {
   client_username_.clear();
   OnStateChanged(kDisconnected);
 }
 
 void HostNPScriptObject::OnShutdown() {
@@ skipping 111 matching lines @@
 
   // Create the Host.
   LOG(INFO) << "Connecting with NAT state: " << nat_traversal_enabled_;
   host_ = ChromotingHost::Create(
       &host_context_, host_config_, desktop_environment_.get(),
       access_verifier.release(), nat_traversal_enabled_);
   host_->AddStatusObserver(this);
   host_->AddStatusObserver(register_request_.get());
   host_->set_it2me(true);
 
+  LocalizeStrings();
+
   // Start the Host.
   host_->Start();
 
   OnStateChanged(kRequestedAccessCode);
   return;
 }
 
 bool HostNPScriptObject::Disconnect(const NPVariant* args,
                                     uint32_t arg_count,
                                     NPVariant* result) {
@@ skipping 140 matching lines @@
   }
 }
 
 void HostNPScriptObject::SetException(const std::string& exception_string) {
   CHECK_EQ(base::PlatformThread::CurrentId(), np_thread_id_);
   g_npnetscape_funcs->setexception(parent_, exception_string.c_str());
   LOG(INFO) << exception_string;
 }
 
 void HostNPScriptObject::LocalizeStrings() {
-  UiStrings* ui_strings = host_->ui_strings();
-  std::string direction;
-  LocalizeString("@@bidi_dir", NULL, &direction);
-  ui_strings->direction =
-      direction == "rtl" ? remoting::UiStrings::RTL
-                         : remoting::UiStrings::LTR;
-  LocalizeString("productName", NULL, &ui_strings->product_name);
-  LocalizeString("disconnectButton", NULL, &ui_strings->disconnect_button_text);
+  UiStrings ui_strings;
+  string16 direction;
+  LocalizeString("@@bidi_dir", &direction);
+  ui_strings.direction = UTF16ToUTF8(direction) == "rtl" ?
+      remoting::UiStrings::RTL : remoting::UiStrings::LTR;
+  LocalizeString("productName", &ui_strings.product_name);
+  LocalizeString("disconnectButton", &ui_strings.disconnect_button_text);
   LocalizeString(
 #if defined(OS_WIN)
       "disconnectButtonPlusShortcutWindows",
 #elif defined(OS_MAC)
       "disconnectButtonPlusShortcutMacOSX",
 #else
       "disconnectButtonPlusShortcutLinux",
 #endif
-      NULL, &ui_strings->disconnect_button_text_plus_shortcut);
-  LocalizeString("continuePrompt", NULL, &ui_strings->continue_prompt);
-  LocalizeString("continueButton", NULL, &ui_strings->continue_button_text);
-  LocalizeString("stopSharingButton", NULL,
-                 &ui_strings->stop_sharing_button_text);
-  LocalizeString("messageShared", client_username_.c_str(),
-                 &ui_strings->disconnect_message);
+      &ui_strings.disconnect_button_text_plus_shortcut);
+  LocalizeString("continuePrompt", &ui_strings.continue_prompt);
+  LocalizeString("continueButton", &ui_strings.continue_button_text);
+  LocalizeString("stopSharingButton",
+                 &ui_strings.stop_sharing_button_text);
+  LocalizeString("messageShared", &ui_strings.disconnect_message);
+
+  host_->SetUiStrings(ui_strings);
 }
 
-bool HostNPScriptObject::LocalizeString(const char* tag,
-                                        const char* substitution,
-                                        std::string* result) {
+bool HostNPScriptObject::LocalizeString(const char* tag, string16* result) {
   NPVariant args[2];
   STRINGZ_TO_NPVARIANT(tag, args[0]);
-  int arg_count = 1;
-  if (substitution) {
-    STRINGZ_TO_NPVARIANT(substitution, args[1]);
-    ++arg_count;
-  }
   NPVariant np_result;
   bool is_good = g_npnetscape_funcs->invokeDefault(
-      plugin_, localize_func_.get(), &args[0], arg_count, &np_result);
+      plugin_, localize_func_.get(), &args[0], 1, &np_result);
   if (!is_good) {
     LOG(ERROR) << "Localization failed for " << tag;
     return false;
   }
   std::string translation = StringFromNPVariant(np_result);
   g_npnetscape_funcs->releasevariantvalue(&np_result);
   if (translation.empty()) {
     LOG(ERROR) << "Missing translation for " << tag;
     return false;
   }
-  *result = translation;
+  *result = UTF8ToUTF16(translation);
   return true;
 }
 
 bool HostNPScriptObject::InvokeAndIgnoreResult(NPObject* func,
                                                const NPVariant* args,
                                                uint32_t argCount) {
   NPVariant np_result;
   bool is_good = g_npnetscape_funcs->invokeDefault(plugin_, func, args,
                                                    argCount, &np_result);
   if (is_good)
       g_npnetscape_funcs->releasevariantvalue(&np_result);
   return is_good;
 }
 
 }  // namespace remoting