Host process i18n and Linux implementation.

remoting/host/plugin/host_script_object.h

 // 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.
 
 #ifndef REMOTING_HOST_PLUGIN_HOST_SCRIPT_OBJECT_H_
 #define REMOTING_HOST_PLUGIN_HOST_SCRIPT_OBJECT_H_
 
 #include <string>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "base/synchronization/cancellation_flag.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
 #include "base/time.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/host_status_observer.h"
+#include "remoting/host/plugin/host_plugin_utils.h"
 #include "third_party/npapi/bindings/npapi.h"
 #include "third_party/npapi/bindings/npfunctions.h"
 #include "third_party/npapi/bindings/npruntime.h"
 
 namespace tracked_objects {
 class Location;
 }  // namespace tracked_objects
 
 namespace remoting {
 
@@ skipping 38 matching lines @@
       remoting::protocol::ConnectionToClient* client) OVERRIDE;
   virtual void OnClientDisconnected(
       remoting::protocol::ConnectionToClient* client) OVERRIDE;
   virtual void OnShutdown() OVERRIDE;
 
   // A Log Message Handler that is called after each LOG message has been
   // processed. This must be of type LogMessageHandlerFunction defined in
   // base/logging.h.
   static bool LogToUI(int severity, const char* file, int line,
                       size_t message_start, const std::string& str);
+
  private:
   enum State {
     kDisconnected,
     kRequestedAccessCode,
     kReceivedAccessCode,
     kConnected,
     kAffirmingConnection,
     kError
   };
 
@@ skipping 20 matching lines @@
   // Helper functions that run on main thread. Can be called on any
   // other thread.
   void ConnectInternal(const std::string& uid,
                        const std::string& auth_token,
                        const std::string& auth_service);
   void DisconnectInternal();
 
   // Callback for ChromotingHost::Shutdown().
   void OnShutdownFinished();
 
+  // Helper function for executing InvokeDefault on an NPObject that performs
+  // a string->string mapping with one optional substitution parameter. Stores
+  // the translation in |result| and returns true on success, or leaves it
+  // unchanged and returns false on failure.

[Wez, 2011/08/13 01:35:32]

Would it make more sense to do the substitution even on failure, so that the
result indicates whether the string was localized, but it'll at least display
the correct information, albeit in English(ish) if not?

[Jamie, 2011/08/13 02:20:15]

The strings have their English translations hard-coded so that
remoting_simple_host still works, so if the translations fails, that's what
you'll get.

+  bool Localize(const char* tag, const char* parameter, std::string* result);
+
   // Helper function for executing InvokeDefault on an NPObject, and ignoring
   // the return value.
   bool InvokeAndIgnoreResult(NPObject* func,
                              const NPVariant* args,
                              uint32_t argCount);
 
   // Posts a task on the main NP thread.
   void PostTaskToNPThread(
       const tracked_objects::Location& from_here, const base::Closure& task);
 
   // Utility function for PostTaskToNPThread.
   static void NPTaskSpringboard(void* task);
 
   // Set an exception for the current call.
   void SetException(const std::string& exception_string);
 
   NPP plugin_;
   NPObject* parent_;
   int state_;
   std::string access_code_;
   std::string client_username_;
   base::TimeDelta access_code_lifetime_;
-  NPObject* log_debug_info_func_;
-  NPObject* on_state_changed_func_;
+  scoped_NPObject localize_func_;
+  scoped_NPObject log_debug_info_func_;
+  scoped_NPObject on_state_changed_func_;
   base::PlatformThreadId np_thread_id_;
 
   scoped_ptr<RegisterSupportHostRequest> register_request_;
   scoped_refptr<MutableHostConfig> host_config_;
   ChromotingHostContext host_context_;
   scoped_ptr<DesktopEnvironment> desktop_environment_;
 
   scoped_refptr<ChromotingHost> host_;
   int failed_login_attempts_;
 
   base::WaitableEvent disconnected_event_;
   base::CancellationFlag destructing_;
 };
 
 }  // namespace remoting
 
 DISABLE_RUNNABLE_METHOD_REFCOUNT(remoting::HostNPScriptObject);
 
 #endif  // REMOTING_HOST_HOST_SCRIPT_OBJECT_H_