Turned UiStrings into a singleton so that the continue window does not depend on ChromotingHost.

remoting/host/plugin/host_script_object.cc

 // Copyright (c) 2012 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/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/message_loop.h"
@@ skipping 68 matching lines @@
 }  // namespace
 
 // Internal implementation of the plugin's It2Me host function.
 class HostNPScriptObject::It2MeImpl
     : public base::RefCountedThreadSafe<It2MeImpl>,
       public HostStatusObserver {
  public:
   It2MeImpl(
       scoped_ptr<ChromotingHostContext> context,
       scoped_refptr<base::SingleThreadTaskRunner> plugin_task_runner,
-      base::WeakPtr<HostNPScriptObject> script_object,
-      const UiStrings& ui_strings);
+      base::WeakPtr<HostNPScriptObject> script_object);
 
   // Methods called by the script object, from the plugin thread.
 
   // Creates It2Me host structures and starts the host.
   void Connect(const std::string& uid,
                const std::string& auth_token,
-               const std::string& auth_service);
+               const std::string& auth_service,
+               const UiStrings& ui_strings);
 
   // Disconnects the host, ready for tear-down.
   // Also called internally, from the network thread.
   void Disconnect();
 
   // Request a NAT policy notification.
   void RequestNatPolicy();
 
   // remoting::HostStatusObserver implementation.
   virtual void OnAccessDenied(const std::string& jid) OVERRIDE;
@@ skipping 33 matching lines @@
   // Called when initial policies are read, and when they change.
   void OnPolicyUpdate(scoped_ptr<base::DictionaryValue> policies);
 
   // Handlers for NAT traversal and host domain policies.
   void UpdateNatPolicy(bool nat_traversal_enabled);
   void UpdateHostDomainPolicy(const std::string& host_domain);
 
   scoped_ptr<ChromotingHostContext> host_context_;
   scoped_refptr<base::SingleThreadTaskRunner> plugin_task_runner_;
   base::WeakPtr<HostNPScriptObject> script_object_;
-  UiStrings ui_strings_;
 
   State state_;
 
   HostKeyPair host_key_pair_;
   scoped_ptr<SignalStrategy> signal_strategy_;
   scoped_ptr<RegisterSupportHostRequest> register_request_;
   scoped_ptr<LogToServer> log_to_server_;
   scoped_ptr<DesktopEnvironmentFactory> desktop_environment_factory_;
   scoped_ptr<It2MeHostUserInterface> it2me_host_user_interface_;
   scoped_ptr<HostEventLogger> host_event_logger_;
@@ skipping 19 matching lines @@
   // it can be executed after at least one successful policy read. This
   // variable contains the thunk if it is necessary.
   base::Closure pending_connect_;
 
   DISALLOW_COPY_AND_ASSIGN(It2MeImpl);
 };
 
 HostNPScriptObject::It2MeImpl::It2MeImpl(
     scoped_ptr<ChromotingHostContext> host_context,
     scoped_refptr<base::SingleThreadTaskRunner> plugin_task_runner,
-    base::WeakPtr<HostNPScriptObject> script_object,
-    const UiStrings& ui_strings)
+    base::WeakPtr<HostNPScriptObject> script_object)
   : host_context_(host_context.Pass()),
     plugin_task_runner_(plugin_task_runner),
     script_object_(script_object),
-    ui_strings_(ui_strings),
     state_(kDisconnected),
     failed_login_attempts_(0),
     nat_traversal_enabled_(false),
     policy_received_(false) {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 }
 
 void HostNPScriptObject::It2MeImpl::Connect(
     const std::string& uid,
     const std::string& auth_token,
-    const std::string& auth_service) {
+    const std::string& auth_service,
+    const UiStrings& ui_strings) {
   if (!host_context_->ui_task_runner()->BelongsToCurrentThread()) {
     DCHECK(plugin_task_runner_->BelongsToCurrentThread());
     host_context_->ui_task_runner()->PostTask(
         FROM_HERE,
-        base::Bind(&It2MeImpl::Connect, this, uid, auth_token, auth_service));
+        base::Bind(&It2MeImpl::Connect, this, uid, auth_token, auth_service,
+                   ui_strings));
     return;
   }
 
   // Create the desktop environment factory.
   desktop_environment_factory_.reset(new DesktopEnvironmentFactory(
       host_context_->input_task_runner(), host_context_->ui_task_runner()));
 
   // Start monitoring configured policies.
   policy_watcher_.reset(
       policy_hack::PolicyWatcher::Create(host_context_->network_task_runner()));
   policy_watcher_->StartWatching(
       base::Bind(&It2MeImpl::OnPolicyUpdate, this));
 
   // The UserInterface object needs to be created on the UI thread.
   it2me_host_user_interface_.reset(
       new It2MeHostUserInterface(host_context_->network_task_runner(),
-                                 host_context_->ui_task_runner()));
+                                 host_context_->ui_task_runner(), ui_strings));
   it2me_host_user_interface_->Init();
 
   // Switch to the network thread to start the actual connection.
   host_context_->network_task_runner()->PostTask(
       FROM_HERE, base::Bind(
           &It2MeImpl::ReadPolicyAndConnect, this,
           uid, auth_token, auth_service));
 }
 
 void HostNPScriptObject::It2MeImpl::Disconnect() {
@@ skipping 133 matching lines @@
   log_to_server_.reset(
       new LogToServer(host_, ServerLogEntry::IT2ME, signal_strategy_.get()));
 
   // Disable audio by default.
   // TODO(sergeyu): Add UI to enable it.
   scoped_ptr<protocol::CandidateSessionConfig> protocol_config =
       protocol::CandidateSessionConfig::CreateDefault();
   protocol::CandidateSessionConfig::DisableAudioChannel(protocol_config.get());
   host_->set_protocol_config(protocol_config.Pass());
 
-  // Provide localization strings to the host.
-  host_->SetUiStrings(ui_strings_);
-
   // Create user interface.
   it2me_host_user_interface_->Start(host_.get(),
                                     base::Bind(&It2MeImpl::Disconnect, this));
 
   // Create event logger.
   host_event_logger_ = HostEventLogger::Create(host_, kApplicationName);
 
   // Connect signaling and start the host.
   signal_strategy_->Connect();
   host_->Start(uid);
@@ skipping 550 matching lines @@
   // Create threads for the Chromoting host & desktop environment to use.
   scoped_ptr<ChromotingHostContext> host_context =
     ChromotingHostContext::Create(plugin_task_runner_);
   if (!host_context) {
     SetException("connect: failed to start threads");
     return false;
   }
 
   // Create the It2Me host implementation and start connecting.
   it2me_impl_ = new It2MeImpl(
-      host_context.Pass(), plugin_task_runner_, weak_ptr_, ui_strings_);
-  it2me_impl_->Connect(uid, auth_token, auth_service);
+      host_context.Pass(), plugin_task_runner_, weak_ptr_);
+  it2me_impl_->Connect(uid, auth_token, auth_service, ui_strings_);
 
   return true;
 }
 
 bool HostNPScriptObject::Disconnect(const NPVariant* args,
                                     uint32_t arg_count,
                                     NPVariant* result) {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
   if (arg_count != 0) {
     SetException("disconnect: bad number of arguments");
@@ skipping 514 matching lines @@
 }
 
 void HostNPScriptObject::SetException(const std::string& exception_string) {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   g_npnetscape_funcs->setexception(parent_, exception_string.c_str());
   LOG(INFO) << exception_string;
 }
 
 }  // namespace remoting