Run LocalizeStrings() on plugin thread.

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/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/string16.h"
 #include "base/threading/platform_thread.h"
 #include "base/time.h"
 #include "remoting/base/plugin_message_loop_proxy.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/host_status_observer.h"
 #include "remoting/host/plugin/host_plugin_utils.h"
+#include "remoting/host/ui_strings.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 62 matching lines @@
   };
 
   // Start connection. args are:
   //   string uid, string auth_token
   // No result.
   bool Connect(const NPVariant* args, uint32_t argCount, NPVariant* result);
 
   // Disconnect. No arguments or result.
   bool Disconnect(const NPVariant* args, uint32_t argCount, NPVariant* result);
 
+  // Localize strings. args are:
+  //   localize_func - a callback function which returns a localized string for
+  //   a given tag name.
+  // No result.
+  bool Localize(const NPVariant* args, uint32_t argCount, NPVariant* result);
+
   // Call OnStateChanged handler if there is one.
   void OnStateChanged(State state);
 
   // Call LogDebugInfo handler if there is one.
   void LogDebugInfo(const std::string& message);
 
   // Callbacks invoked during session setup.
   void OnReceivedSupportID(remoting::SupportAccessVerifier* access_verifier,
                            bool success,
                            const std::string& support_id,
                            const base::TimeDelta& lifetime);
 
   // Helper functions that run on main thread. Can be called on any
   // other thread.
   void ReadPolicyAndConnect(const std::string& uid,
                             const std::string& auth_token,
                             const std::string& auth_service);
   void FinishConnect(const std::string& uid,
                        const std::string& auth_token,
                        const std::string& auth_service);
   void DisconnectInternal();
 
   // Callback for ChromotingHost::Shutdown().
   void OnShutdownFinished();
 
   // Called when the nat traversal policy is updated.
   void OnNatPolicyUpdate(bool nat_traversal_enabled);
 
-  void LocalizeStrings();
+  void LocalizeStrings(ScopedRefNPObject *localize_func);

[Jamie, 2011/08/30 00:43:34]

Not a big deal, but why not a const reference?

[Sergey Ulanov, 2011/08/30 00:53:08]

Here and in other places: star is in a wrong place.
Does it need to be ScopedRefNPObject? Why can't you just pass NPObject*?

[Jamie, 2011/08/30 00:57:55]

That's a good point. With hindsight, NPObject* is the obvious choice.

[Lambros, 2011/08/30 01:49:26]

Done.

 
   // 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.
-  bool LocalizeString(const char* tag, string16* result);
+  bool LocalizeString(ScopedRefNPObject *localize_func, const char* tag,
+                      string16* result);
 
   // Helper function for executing InvokeDefault on an NPObject, and ignoring
   // the return value.
   bool InvokeAndIgnoreResult(NPObject* func,
                              const NPVariant* args,
                              uint32_t argCount);
 
   // 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_;
-  ScopedRefNPObject localize_func_;
   ScopedRefNPObject log_debug_info_func_;
   ScopedRefNPObject on_state_changed_func_;
   base::PlatformThreadId np_thread_id_;
   scoped_refptr<PluginMessageLoopProxy> plugin_message_loop_proxy_;
 
   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_;
 
+  UiStrings ui_strings_;
+  base::Lock ui_strings_lock_;
+
   base::WaitableEvent disconnected_event_;
 
   scoped_ptr<policy_hack::NatPolicy> nat_policy_;
 
   // Host the current nat traversal policy setting.
   bool nat_traversal_enabled_;
 
   // Indiciates whether or not a policy has ever been read. This is to ensure
   // that on startup, we do not accidentally start a connection before we have
   // queried our policy restrictions.
   bool policy_received_;
 
   // On startup, it is possible to have Connect() called before the policy read
   // is completed.  Rather than just failing, we thunk the connection call so
   // it can be executed after at least one successful policy read. This
   // variable contains the thunk if it is necessary.
   base::Closure pending_connect_;
 };
 
 }  // namespace remoting
 
 DISABLE_RUNNABLE_METHOD_REFCOUNT(remoting::HostNPScriptObject);
 
 #endif  // REMOTING_HOST_HOST_SCRIPT_OBJECT_H_