Host process i18n and Linux implementation.

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/threading/platform_thread.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/host_plugin_utils.h"
 #include "remoting/host/register_support_host_request.h"
 #include "remoting/host/support_access_verifier.h"
+#include "remoting/host/ui_strings.h"
 
 namespace remoting {
 
 // Supported Javascript interface:
 // readonly attribute string accessCode;
 // readonly attribute int accessCodeLifetime;
 // readonly attribute string client;
 // readonly attribute int state;
 //
 // state: {
 //     DISCONNECTED,
 //     REQUESTED_ACCESS_CODE,
 //     RECEIVED_ACCESS_CODE,
 //     CONNECTED,
 //     AFFIRMING_CONNECTION,
 //     ERROR,
 // }
 //
 // attribute Function void logDebugInfo(string);
 // attribute Function void onStateChanged();
+// attribute Function string localize(string,...);
 //
 // // The |auth_service_with_token| parameter should be in the format
 // // "auth_service:auth_token".  An example would be "oauth2:1/2a3912vd".
 // void connect(string uid, string auth_service_with_token);
 // void disconnect();
 
 namespace {
 
 const char* kAttrNameAccessCode = "accessCode";
 const char* kAttrNameAccessCodeLifetime = "accessCodeLifetime";
 const char* kAttrNameClient = "client";
 const char* kAttrNameState = "state";
+const char* kAttrNameLocalize = "localize";
 const char* kAttrNameLogDebugInfo = "logDebugInfo";
 const char* kAttrNameOnStateChanged = "onStateChanged";
 const char* kFuncNameConnect = "connect";
 const char* kFuncNameDisconnect = "disconnect";
 
 // States.
 const char* kAttrNameDisconnected = "DISCONNECTED";
 const char* kAttrNameRequestedAccessCode = "REQUESTED_ACCESS_CODE";
 const char* kAttrNameReceivedAccessCode = "RECEIVED_ACCESS_CODE";
 const char* kAttrNameConnected = "CONNECTED";
 const char* kAttrNameAffirmingConnection = "AFFIRMING_CONNECTION";
 const char* kAttrNameError = "ERROR";
 
 const int kMaxLoginAttempts = 5;
 
 }  // namespace
 
 // This flag blocks LOGs to the UI if we're already in the middle of logging
 // to the UI. This prevents a potential infinite loop if we encounter an error
 // while sending the log message to the UI.
 static bool g_logging_to_plugin = false;
 static HostNPScriptObject* g_logging_scriptable_object = NULL;
 static logging::LogMessageHandlerFunction g_logging_old_handler = NULL;
 
 HostNPScriptObject::HostNPScriptObject(NPP plugin, NPObject* parent)
     : plugin_(plugin),
       parent_(parent),
       state_(kDisconnected),
-      log_debug_info_func_(NULL),
-      on_state_changed_func_(NULL),
       np_thread_id_(base::PlatformThread::CurrentId()),
       failed_login_attempts_(0),
       disconnected_event_(true, false) {
   // Set up log message handler.
   // Note that this approach doesn't quite support having multiple instances
   // of Chromoting running. In that case, the most recently opened tab will
   // grab all the debug log messages, and when any Chromoting tab is closed
   // the logging handler will go away.
   // Since having multiple Chromoting tabs is not a primary use case, and this
   // is just debug logging, we're punting improving debug log support for that
@@ skipping 23 matching lines @@
   // here because |host_context_| needs to be stopped on the plugin
   // thread, but the plugin thread may not exist after the instance
   // is destroyed.
   destructing_.Set();
   disconnected_event_.Reset();
   DisconnectInternal();
   disconnected_event_.Wait();
 
   // Stop all threads.
   host_context_.Stop();
-
-  if (log_debug_info_func_) {
-    g_npnetscape_funcs->releaseobject(log_debug_info_func_);
-  }
-  if (on_state_changed_func_) {
-    g_npnetscape_funcs->releaseobject(on_state_changed_func_);
-  }
 }
 
 bool HostNPScriptObject::Init() {
   VLOG(2) << "Init";
   // TODO(wez): This starts a bunch of threads, which might fail.
   host_context_.Start();
   return true;
 }
 
 bool HostNPScriptObject::HasMethod(const std::string& method_name) {
@@ skipping 28 matching lines @@
   }
 }
 
 bool HostNPScriptObject::HasProperty(const std::string& property_name) {
   VLOG(2) << "HasProperty " << property_name;
   CHECK_EQ(base::PlatformThread::CurrentId(), np_thread_id_);
   return (property_name == kAttrNameAccessCode ||
           property_name == kAttrNameAccessCodeLifetime ||
           property_name == kAttrNameClient ||
           property_name == kAttrNameState ||
+          property_name == kAttrNameLocalize ||
           property_name == kAttrNameLogDebugInfo ||
           property_name == kAttrNameOnStateChanged ||
           property_name == kAttrNameDisconnected ||
           property_name == kAttrNameRequestedAccessCode ||
           property_name == kAttrNameReceivedAccessCode ||
           property_name == kAttrNameConnected ||
           property_name == kAttrNameAffirmingConnection ||
           property_name == kAttrNameError);
 }
 
 bool HostNPScriptObject::GetProperty(const std::string& property_name,
                                      NPVariant* result) {
   VLOG(2) << "GetProperty " << property_name;
   CHECK_EQ(base::PlatformThread::CurrentId(), np_thread_id_);
   if (!result) {
     SetException("GetProperty: NULL result");
     return false;
   }
 
   if (property_name == kAttrNameOnStateChanged) {
-    OBJECT_TO_NPVARIANT(on_state_changed_func_, *result);
+    OBJECT_TO_NPVARIANT(on_state_changed_func_.get(), *result);
+    return true;
+  } else if (property_name == kAttrNameLocalize) {
+    OBJECT_TO_NPVARIANT(localize_func_.get(), *result);
     return true;
   } else if (property_name == kAttrNameLogDebugInfo) {
-    OBJECT_TO_NPVARIANT(log_debug_info_func_, *result);
+    OBJECT_TO_NPVARIANT(log_debug_info_func_.get(), *result);
     return true;
   } else if (property_name == kAttrNameState) {
     INT32_TO_NPVARIANT(state_, *result);
     return true;
   } else if (property_name == kAttrNameAccessCode) {
     *result = NPVariantFromString(access_code_);
     return true;
   } else if (property_name == kAttrNameAccessCodeLifetime) {
     INT32_TO_NPVARIANT(access_code_lifetime_.InSeconds(), *result);
     return true;
@@ skipping 24 matching lines @@
   }
 }
 
 bool HostNPScriptObject::SetProperty(const std::string& property_name,
                                      const NPVariant* value) {
   VLOG(2) <<  "SetProperty " << property_name;
   CHECK_EQ(base::PlatformThread::CurrentId(), np_thread_id_);
 
   if (property_name == kAttrNameOnStateChanged) {
     if (NPVARIANT_IS_OBJECT(*value)) {
-      if (on_state_changed_func_) {
-        g_npnetscape_funcs->releaseobject(on_state_changed_func_);
-      }
-      on_state_changed_func_ = NPVARIANT_TO_OBJECT(*value);
-      if (on_state_changed_func_) {
-        g_npnetscape_funcs->retainobject(on_state_changed_func_);
-      }
+      on_state_changed_func_.replace(NPVARIANT_TO_OBJECT(*value));
       return true;
     } else {
       SetException("SetProperty: unexpected type for property " +
+                   property_name);
+    }
+    return false;
+  }
+
+  if (property_name == kAttrNameLocalize) {
+    if (NPVARIANT_IS_OBJECT(*value)) {
+      localize_func_.replace(NPVARIANT_TO_OBJECT(*value));
+      return true;
+    } else {
+      SetException("SetProperty: unexpected type for property " +
                    property_name);
     }
     return false;
   }
 
   if (property_name == kAttrNameLogDebugInfo) {
     if (NPVARIANT_IS_OBJECT(*value)) {
-      if (log_debug_info_func_) {
-        g_npnetscape_funcs->releaseobject(log_debug_info_func_);
-      }
-      log_debug_info_func_ = NPVARIANT_TO_OBJECT(*value);
-      if (log_debug_info_func_) {
-        g_npnetscape_funcs->retainobject(log_debug_info_func_);
-      }
+      log_debug_info_func_.replace(NPVARIANT_TO_OBJECT(*value));
       return true;
     } else {
       SetException("SetProperty: unexpected type for property " +
                    property_name);
     }
     return false;
   }
 
   return false;
 }
 
 bool HostNPScriptObject::RemoveProperty(const std::string& property_name) {
   VLOG(2) << "RemoveProperty " << property_name;
   CHECK_EQ(base::PlatformThread::CurrentId(), np_thread_id_);
   return false;
 }
 
 bool HostNPScriptObject::Enumerate(std::vector<std::string>* values) {
   VLOG(2) << "Enumerate";
   CHECK_EQ(base::PlatformThread::CurrentId(), np_thread_id_);
   const char* entries[] = {
     kAttrNameAccessCode,
     kAttrNameState,
+    kAttrNameLocalize,
     kAttrNameLogDebugInfo,
     kAttrNameOnStateChanged,
     kFuncNameConnect,
     kFuncNameDisconnect,
     kAttrNameDisconnected,
     kAttrNameRequestedAccessCode,
     kAttrNameReceivedAccessCode,
     kAttrNameConnected,
     kAttrNameAffirmingConnection,
     kAttrNameError
@@ skipping 20 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.";
+  UiStrings* ui_strings = host_->ui_strings();
+  std::string direction;
+  Localize("@@bidi_dir", NULL, &direction);
+  ui_strings->direction =
+      direction == "rtl" ? remoting::UiStrings::RTL
+                         : remoting::UiStrings::LTR;
+  Localize("productName", NULL, &ui_strings->productName);
+  Localize("disconnectButton", NULL, &ui_strings->disconnectButtonText);
+  Localize(
+#if defined(OS_WIN)
+      "disconnectButtonShortcutWindows",
+#elif defined(OS_MAC)
+      "disconnectButtonShortcutMacOSX",
+#else
+      "disconnectButtonShortcutLinux",
+#endif
+      NULL, &ui_strings->disconnectButtonShortcut);
+  Localize("continuePrompt", NULL, &ui_strings->continuePrompt);
+  Localize("continueButton", NULL, &ui_strings->continueButtonText);
+  Localize("stopSharingButton", NULL, &ui_strings->stopSharingButtonText);
+  Localize("messageShared", client_username_.c_str(),
+           &ui_strings->disconnectMessage);
   OnStateChanged(kConnected);
 }
 
 void HostNPScriptObject::OnClientDisconnected(
     remoting::protocol::ConnectionToClient* client) {
   client_username_.clear();
   OnStateChanged(kDisconnected);
 }
 
 void HostNPScriptObject::OnShutdown() {
@@ skipping 170 matching lines @@
   if (destructing_.IsSet())
     return;
 
   if (!host_context_.IsUIThread()) {
     host_context_.PostTaskToUIThread(
         FROM_HERE, base::Bind(&HostNPScriptObject::OnStateChanged,
                               base::Unretained(this), state));
     return;
   }
   state_ = state;
-  if (on_state_changed_func_) {
+  if (on_state_changed_func_.get()) {
     VLOG(2) << "Calling state changed " << state;
-    bool is_good = InvokeAndIgnoreResult(on_state_changed_func_, NULL, 0);
+    bool is_good = InvokeAndIgnoreResult(on_state_changed_func_.get(), NULL, 0);
     LOG_IF(ERROR, !is_good) << "OnStateChanged failed";
   }
 }
 
 // static
 bool HostNPScriptObject::LogToUI(int severity, const char* file, int line,
                                  size_t message_start,
                                  const std::string& str) {
   // The |g_logging_to_plugin| check is to prevent logging to the scriptable
   // object if we're already in the middle of logging.
@@ skipping 15 matching lines @@
   if (destructing_.IsSet())
     return;
 
   if (!host_context_.IsUIThread()) {
     host_context_.PostTaskToUIThread(
         FROM_HERE, base::Bind(&HostNPScriptObject::LogDebugInfo,
                               base::Unretained(this), message));
     return;
   }
 
-  if (log_debug_info_func_) {
+  if (log_debug_info_func_.get()) {
     NPVariant log_message;
     STRINGZ_TO_NPVARIANT(message.c_str(), log_message);
-    bool is_good = InvokeAndIgnoreResult(log_debug_info_func_,
+    bool is_good = InvokeAndIgnoreResult(log_debug_info_func_.get(),
                                          &log_message, 1);
     LOG_IF(ERROR, !is_good) << "LogDebugInfo failed";
   }
 }
 
 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;
 }
 
+bool HostNPScriptObject::Localize(const char* tag, const char* parameter,
+                                  std::string* result) {
+  NPVariant args[2];
+  STRINGZ_TO_NPVARIANT(tag, args[0]);
+  if (parameter) {
+    STRINGZ_TO_NPVARIANT(parameter, args[1]);
+  }
+  NPVariant np_result;
+  bool is_good = g_npnetscape_funcs->invokeDefault(
+      plugin_, localize_func_.get(), &args[0], parameter ? 2 : 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;
+  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;
 }
@@ skipping 13 matching lines @@
 }
 
 // static
 void HostNPScriptObject::NPTaskSpringboard(void* task) {
   base::Closure* real_task = reinterpret_cast<base::Closure*>(task);
   real_task->Run();
   delete real_task;
 }
 
 }  // namespace remoting