diff options
| -rw-r--r-- | remoting/base/scoped_thread_proxy.cc | 86 | ||||
| -rw-r--r-- | remoting/base/scoped_thread_proxy.h | 73 | ||||
| -rw-r--r-- | remoting/client/chromoting_client.cc | 15 | ||||
| -rw-r--r-- | remoting/client/chromoting_client.h | 6 | ||||
| -rw-r--r-- | remoting/client/plugin/chromoting_instance.cc | 57 | ||||
| -rw-r--r-- | remoting/client/plugin/chromoting_instance.h | 3 | ||||
| -rw-r--r-- | remoting/host/desktop_environment.h | 1 | ||||
| -rw-r--r-- | remoting/host/host_user_interface.cc | 30 | ||||
| -rw-r--r-- | remoting/host/host_user_interface.h | 8 | ||||
| -rw-r--r-- | remoting/host/it2me_host_user_interface.cc | 41 | ||||
| -rw-r--r-- | remoting/host/it2me_host_user_interface.h | 6 | ||||
| -rw-r--r-- | remoting/remoting.gyp | 2 |
12 files changed, 84 insertions, 244 deletions
diff --git a/remoting/base/scoped_thread_proxy.cc b/remoting/base/scoped_thread_proxy.cc deleted file mode 100644 index d1dcc26..0000000 --- a/remoting/base/scoped_thread_proxy.cc +++ /dev/null @@ -1,86 +0,0 @@ -// 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/base/scoped_thread_proxy.h" - -#include "base/bind.h" - -namespace remoting { - -class ScopedThreadProxy::Core : public base::RefCountedThreadSafe<Core> { - public: - Core(base::MessageLoopProxy* message_loop) - : message_loop_(message_loop), - canceled_(false) { - } - - void PostTask(const tracked_objects::Location& from_here, - const base::Closure& closure) { - if (!canceled_) - message_loop_->PostTask(from_here, Wrap(closure)); - } - - void PostDelayedTask( - const tracked_objects::Location& from_here, - const base::Closure& closure, - int64 delay_ms) { - if (!canceled_) { - message_loop_->PostDelayedTask(from_here, Wrap(closure), delay_ms); - } - } - - void Detach() { - DCHECK(message_loop_->BelongsToCurrentThread()); - canceled_ = true; - } - - private: - friend class base::RefCountedThreadSafe<Core>; - - ~Core() { - DCHECK(canceled_); - } - - base::Closure Wrap(const base::Closure& closure) { - return base::Bind(&Core::CallClosure, this, closure); - } - - void CallClosure(const base::Closure& closure) { - DCHECK(message_loop_->BelongsToCurrentThread()); - - if (!canceled_) - closure.Run(); - } - - scoped_refptr<base::MessageLoopProxy> message_loop_; - bool canceled_; - - DISALLOW_COPY_AND_ASSIGN(Core); -}; - -ScopedThreadProxy::ScopedThreadProxy(base::MessageLoopProxy* message_loop) - : core_(new Core(message_loop)) { -} - -ScopedThreadProxy::~ScopedThreadProxy() { - Detach(); -} - -void ScopedThreadProxy::PostTask(const tracked_objects::Location& from_here, - const base::Closure& closure) { - core_->PostTask(from_here, closure); -} - -void ScopedThreadProxy::PostDelayedTask( - const tracked_objects::Location& from_here, - const base::Closure& closure, - int64 delay_ms) { - core_->PostDelayedTask(from_here, closure, delay_ms); -} - -void ScopedThreadProxy::Detach() { - core_->Detach(); -} - -} // namespace remoting diff --git a/remoting/base/scoped_thread_proxy.h b/remoting/base/scoped_thread_proxy.h deleted file mode 100644 index 9e43a15..0000000 --- a/remoting/base/scoped_thread_proxy.h +++ /dev/null @@ -1,73 +0,0 @@ -// 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. - -#ifndef REMOTING_BASE_SCOPED_THREAD_PROXY_H_ -#define REMOTING_BASE_SCOPED_THREAD_PROXY_H_ - -#include "base/callback_forward.h" -#include "base/message_loop_proxy.h" - -namespace remoting { - -// ScopedThreadProxy is proxy for message loops that cancels all -// pending tasks when it is destroyed. It can be used to post tasks -// for a non-refcounted object. Must be deleted on the thread it -// belongs to. -// -// -// The main difference from WeakPtr<> is that this class can be used safely to -// post tasks from different threads. -// It is similar to WeakHandle<> used in sync: the main difference is -// that WeakHandle<> creates closures itself, while ScopedThreadProxy -// accepts base::Closure instances which caller needs to create using -// base::Bind(). -// -// TODO(sergeyu): Potentially we could use WeakHandle<> instead of -// this class. Consider migrating to WeakHandle<> when it is moved to -// src/base and support for delayed tasks is implemented. -// -// Usage: -// class MyClass { -// public: -// MyClass() -// : thread_proxy_(base::MessageLoopProxy::current()) {} -// -// // Always called on the thread on which this object was created. -// void NonThreadSafeMethod() {} -// -// // Can be called on any thread. -// void ThreadSafeMethod() { -// thread_proxy_.PostTask(FROM_HERE, base::Bind( -// &MyClass::NonThreadSafeMethod, base::Unretained(this))); -// } -// -// private: -// ScopedThreadProxy thread_proxy_; -// }; -class ScopedThreadProxy { - public: - ScopedThreadProxy(base::MessageLoopProxy* message_loop); - ~ScopedThreadProxy(); - - void PostTask(const tracked_objects::Location& from_here, - const base::Closure& closure); - void PostDelayedTask(const tracked_objects::Location& from_here, - const base::Closure& closure, - int64 delay_ms); - - // Cancels all tasks posted via this proxy. Must be called on the - // thread this object belongs to. - void Detach(); - - private: - class Core; - - scoped_refptr<Core> core_; - - DISALLOW_COPY_AND_ASSIGN(ScopedThreadProxy); -}; - -} // namespace remoting - -#endif // REMOTING_BASE_SCOPED_THREAD_PROXY_H_ diff --git a/remoting/client/chromoting_client.cc b/remoting/client/chromoting_client.cc index 4dabdd2..2a3aa56 100644 --- a/remoting/client/chromoting_client.cc +++ b/remoting/client/chromoting_client.cc @@ -41,7 +41,7 @@ ChromotingClient::ChromotingClient(const ClientConfig& config, client_done_(client_done), packet_being_processed_(false), last_sequence_number_(0), - thread_proxy_(context_->network_message_loop()) { + weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) { } ChromotingClient::~ChromotingClient() { @@ -52,6 +52,9 @@ void ChromotingClient::Start( scoped_ptr<protocol::TransportFactory> transport_factory) { DCHECK(message_loop()->BelongsToCurrentThread()); + // Create a WeakPtr to ourself for to use for all posted tasks. + weak_ptr_ = weak_factory_.GetWeakPtr(); + scoped_ptr<protocol::Authenticator> authenticator; if (config_.use_v1_authenticator) { authenticator.reset(new protocol::V1ClientAuthenticator( @@ -75,7 +78,7 @@ void ChromotingClient::Stop(const base::Closure& shutdown_task) { if (!message_loop()->BelongsToCurrentThread()) { message_loop()->PostTask( FROM_HERE, base::Bind(&ChromotingClient::Stop, - base::Unretained(this), shutdown_task)); + weak_ptr_, shutdown_task)); return; } @@ -87,7 +90,7 @@ void ChromotingClient::Stop(const base::Closure& shutdown_task) { } connection_->Disconnect(base::Bind(&ChromotingClient::OnDisconnected, - base::Unretained(this), shutdown_task)); + weak_ptr_, shutdown_task)); } void ChromotingClient::OnDisconnected(const base::Closure& shutdown_task) { @@ -192,7 +195,7 @@ base::MessageLoopProxy* ChromotingClient::message_loop() { void ChromotingClient::OnPacketDone(bool last_packet, base::Time decode_start) { if (!message_loop()->BelongsToCurrentThread()) { - thread_proxy_.PostTask(FROM_HERE, base::Bind( + message_loop()->PostTask(FROM_HERE, base::Bind( &ChromotingClient::OnPacketDone, base::Unretained(this), last_packet, decode_start)); return; @@ -216,8 +219,8 @@ void ChromotingClient::OnPacketDone(bool last_packet, void ChromotingClient::Initialize() { if (!message_loop()->BelongsToCurrentThread()) { - thread_proxy_.PostTask(FROM_HERE, base::Bind( - &ChromotingClient::Initialize, base::Unretained(this))); + message_loop()->PostTask(FROM_HERE, base::Bind( + &ChromotingClient::Initialize, weak_ptr_)); return; } diff --git a/remoting/client/chromoting_client.h b/remoting/client/chromoting_client.h index d784b5a..7b90be3 100644 --- a/remoting/client/chromoting_client.h +++ b/remoting/client/chromoting_client.h @@ -10,8 +10,8 @@ #include <list> #include "base/callback.h" +#include "base/memory/weak_ptr.h" #include "base/time.h" -#include "remoting/base/scoped_thread_proxy.h" #include "remoting/client/client_config.h" #include "remoting/client/chromoting_stats.h" #include "remoting/client/chromoting_view.h" @@ -120,7 +120,9 @@ class ChromotingClient : public protocol::ConnectionToHost::HostEventCallback, // Keep track of the last sequence number bounced back from the host. int64 last_sequence_number_; - ScopedThreadProxy thread_proxy_; + // WeakPtr used to avoid tasks accessing the client after it is deleted. + base::WeakPtrFactory<ChromotingClient> weak_factory_; + base::WeakPtr<ChromotingClient> weak_ptr_; DISALLOW_COPY_AND_ASSIGN(ChromotingClient); }; diff --git a/remoting/client/plugin/chromoting_instance.cc b/remoting/client/plugin/chromoting_instance.cc index fec261e..28556b4 100644 --- a/remoting/client/plugin/chromoting_instance.cc +++ b/remoting/client/plugin/chromoting_instance.cc @@ -97,7 +97,10 @@ std::string ConnectionErrorToString(ChromotingInstance::ConnectionError error) { // while sending the log message to the UI. static bool g_logging_to_plugin = false; static bool g_has_logging_instance = false; -static ChromotingInstance* g_logging_instance = NULL; +CR_DEFINE_STATIC_LOCAL( + scoped_refptr<base::SingleThreadTaskRunner>, g_logging_task_runner, ()); +CR_DEFINE_STATIC_LOCAL( + base::WeakPtr<ChromotingInstance>, g_logging_instance, ()); static logging::LogMessageHandlerFunction g_logging_old_handler = NULL; static base::LazyInstance<base::Lock>::Leaky @@ -139,7 +142,7 @@ ChromotingInstance::ChromotingInstance(PP_Instance pp_instance) plugin_message_loop_( new PluginMessageLoopProxy(&plugin_thread_delegate_)), context_(plugin_message_loop_), - thread_proxy_(new ScopedThreadProxy(plugin_message_loop_)) { + weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) { RequestInputEvents(PP_INPUTEVENT_CLASS_MOUSE | PP_INPUTEVENT_CLASS_WHEEL); RequestFilteringInputEvents(PP_INPUTEVENT_CLASS_KEYBOARD); @@ -157,10 +160,6 @@ ChromotingInstance::ChromotingInstance(PP_Instance pp_instance) ChromotingInstance::~ChromotingInstance() { DCHECK(plugin_message_loop_->BelongsToCurrentThread()); - // Detach the log proxy so we don't log anything else to the UI. - // This needs to be done before the instance is unregistered for logging. - thread_proxy_->Detach(); - // Unregister this instance so that debug log messages will no longer be sent // to it. This will stop all logging in all Chromoting instances. UnregisterLoggingInstance(); @@ -175,10 +174,7 @@ ChromotingInstance::~ChromotingInstance() { // Stopping the context shuts down all chromoting threads. context_.Stop(); - // Delete |thread_proxy_| before we detach |plugin_message_loop_|, - // otherwise ScopedThreadProxy may DCHECK when being destroyed. - thread_proxy_.reset(); - + // Ensure that nothing touches the plugin thread delegate after this point. plugin_message_loop_->Detach(); } @@ -614,7 +610,8 @@ void ChromotingInstance::RegisterLoggingInstance() { // and display them to the user. // If multiple plugins are run, then the last one registered will handle all // logging for all instances. - g_logging_instance = this; + g_logging_instance = weak_factory_.GetWeakPtr(); + g_logging_task_runner = plugin_message_loop_; g_has_logging_instance = true; } @@ -622,12 +619,13 @@ void ChromotingInstance::UnregisterLoggingInstance() { base::AutoLock lock(g_logging_lock.Get()); // Don't unregister unless we're the currently registered instance. - if (this != g_logging_instance) + if (this != g_logging_instance.get()) return; // Unregister this instance for logging. g_has_logging_instance = false; - g_logging_instance = NULL; + g_logging_instance.reset(); + g_logging_task_runner = NULL; VLOG(1) << "Unregistering global log handler"; } @@ -649,24 +647,26 @@ bool ChromotingInstance::LogToUI(int severity, const char* file, int line, // the lock and check |g_logging_instance| unnecessarily. This is not // problematic because we always set |g_logging_instance| inside a lock. if (g_has_logging_instance) { - // Do not LOG anything while holding this lock or else the code will - // deadlock while trying to re-get the lock we're already in. - base::AutoLock lock(g_logging_lock.Get()); - if (g_logging_instance && - // If |g_logging_to_plugin| is set and we're on the logging thread, then - // this LOG message came from handling a previous LOG message and we - // should skip it to avoid an infinite loop of LOG messages. - // We don't have a lock around |g_in_processtoui|, but that's OK since - // the value is only read/written on the logging thread. - (!g_logging_instance->plugin_message_loop_->BelongsToCurrentThread() || - !g_logging_to_plugin)) { + scoped_refptr<base::SingleThreadTaskRunner> logging_task_runner; + + { + base::AutoLock lock(g_logging_lock.Get()); + // If we're on the logging thread and |g_logging_to_plugin| is set then + // this LOG message came from handling a previous LOG message and we + // should skip it to avoid an infinite loop of LOG messages. + if (!g_logging_task_runner->BelongsToCurrentThread() || + !g_logging_to_plugin) { + logging_task_runner = g_logging_task_runner; + } + } + + if (logging_task_runner.get()) { std::string message = remoting::GetTimestampString(); message += (str.c_str() + message_start); - // |thread_proxy_| is safe to use here because we detach it before - // tearing down the |g_logging_instance|. - g_logging_instance->thread_proxy_->PostTask( + + g_logging_task_runner->PostTask( FROM_HERE, base::Bind(&ChromotingInstance::ProcessLogToUI, - base::Unretained(g_logging_instance), message)); + g_logging_instance, message)); } } @@ -681,6 +681,7 @@ void ChromotingInstance::ProcessLogToUI(const std::string& message) { // This flag (which is set only here) is used to prevent LogToUI from posting // new tasks while we're in the middle of servicing a LOG call. This can // happen if the call to LogDebugInfo tries to LOG anything. + // Since it is read on the plugin thread, we don't need to lock to set it. g_logging_to_plugin = true; ChromotingScriptableObject* scriptable_object = GetScriptableObject(); if (scriptable_object) { diff --git a/remoting/client/plugin/chromoting_instance.h b/remoting/client/plugin/chromoting_instance.h index a489bde..0f1bdde 100644 --- a/remoting/client/plugin/chromoting_instance.h +++ b/remoting/client/plugin/chromoting_instance.h @@ -25,7 +25,6 @@ #endif #include "ppapi/cpp/private/instance_private.h" -#include "remoting/base/scoped_thread_proxy.h" #include "remoting/client/client_context.h" #include "remoting/client/key_event_mapper.h" #include "remoting/client/plugin/mac_key_event_processor.h" @@ -225,7 +224,7 @@ class ChromotingInstance : // This wraps a ChromotingScriptableObject in a pp::Var. pp::Var instance_object_; - scoped_ptr<ScopedThreadProxy> thread_proxy_; + base::WeakPtrFactory<ChromotingInstance> weak_factory_; DISALLOW_COPY_AND_ASSIGN(ChromotingInstance); }; diff --git a/remoting/host/desktop_environment.h b/remoting/host/desktop_environment.h index f49fcdc..6d1d80c 100644 --- a/remoting/host/desktop_environment.h +++ b/remoting/host/desktop_environment.h @@ -11,7 +11,6 @@ #include "base/memory/ref_counted.h" #include "base/memory/scoped_ptr.h" #include "base/time.h" -#include "remoting/base/scoped_thread_proxy.h" #include "remoting/host/event_executor.h" namespace remoting { diff --git a/remoting/host/host_user_interface.cc b/remoting/host/host_user_interface.cc index 4401fb5..964473b 100644 --- a/remoting/host/host_user_interface.cc +++ b/remoting/host/host_user_interface.cc @@ -16,7 +16,8 @@ HostUserInterface::HostUserInterface(ChromotingHostContext* context) : host_(NULL), context_(context), is_monitoring_local_inputs_(false), - ui_thread_proxy_(context->ui_message_loop()) { + ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)), + weak_ptr_(weak_factory_.GetWeakPtr()) { } HostUserInterface::~HostUserInterface() { @@ -24,8 +25,6 @@ HostUserInterface::~HostUserInterface() { MonitorLocalInputs(false); ShowDisconnectWindow(false, std::string()); - - ui_thread_proxy_.Detach(); } void HostUserInterface::Start(ChromotingHost* host, @@ -42,19 +41,23 @@ void HostUserInterface::Start(ChromotingHost* host, } void HostUserInterface::OnClientAuthenticated(const std::string& jid) { + DCHECK(network_message_loop()->BelongsToCurrentThread()); + authenticated_jid_ = jid; std::string username = jid.substr(0, jid.find('/')); - ui_thread_proxy_.PostTask(FROM_HERE, base::Bind( + ui_message_loop()->PostTask(FROM_HERE, base::Bind( &HostUserInterface::ProcessOnClientAuthenticated, - base::Unretained(this), username)); + weak_ptr_, username)); } void HostUserInterface::OnClientDisconnected(const std::string& jid) { + DCHECK(network_message_loop()->BelongsToCurrentThread()); + if (jid == authenticated_jid_) { - ui_thread_proxy_.PostTask(FROM_HERE, base::Bind( + ui_message_loop()->PostTask(FROM_HERE, base::Bind( &HostUserInterface::ProcessOnClientDisconnected, - base::Unretained(this))); + weak_ptr_)); } } @@ -62,20 +65,20 @@ void HostUserInterface::OnAccessDenied(const std::string& jid) { } void HostUserInterface::OnShutdown() { + DCHECK(network_message_loop()->BelongsToCurrentThread()); + // Host status observers must be removed on the network thread, so // it must happen here instead of in the destructor. host_->RemoveStatusObserver(this); host_ = NULL; - disconnect_callback_ = base::Closure(); } void HostUserInterface::OnDisconnectCallback() { DCHECK(ui_message_loop()->BelongsToCurrentThread()); - DCHECK(!disconnect_callback_.is_null()); MonitorLocalInputs(false); ShowDisconnectWindow(false, std::string()); - disconnect_callback_.Run(); + DisconnectSession(); } base::MessageLoopProxy* HostUserInterface::network_message_loop() const { @@ -86,7 +89,10 @@ base::MessageLoopProxy* HostUserInterface::ui_message_loop() const { } void HostUserInterface::DisconnectSession() const { - return disconnect_callback_.Run(); + DCHECK(ui_message_loop()->BelongsToCurrentThread()); + DCHECK(!disconnect_callback_.is_null()); + + disconnect_callback_.Run(); } void HostUserInterface::ProcessOnClientAuthenticated( @@ -140,7 +146,7 @@ void HostUserInterface::ShowDisconnectWindow(bool show, disconnect_window_->Show( host_, base::Bind(&HostUserInterface::OnDisconnectCallback, - base::Unretained(this)), + weak_ptr_), username); } else { disconnect_window_->Hide(); diff --git a/remoting/host/host_user_interface.h b/remoting/host/host_user_interface.h index 9c2729e..942cd2a 100644 --- a/remoting/host/host_user_interface.h +++ b/remoting/host/host_user_interface.h @@ -11,8 +11,8 @@ #include "base/callback.h" #include "base/compiler_specific.h" #include "base/memory/scoped_ptr.h" - -#include "remoting/base/scoped_thread_proxy.h" +#include "base/memory/weak_ptr.h" +#include "base/message_loop_proxy.h" #include "remoting/host/host_status_observer.h" namespace remoting { @@ -95,7 +95,9 @@ class HostUserInterface : public HostStatusObserver { bool is_monitoring_local_inputs_; - ScopedThreadProxy ui_thread_proxy_; + // WeakPtr used to avoid tasks accessing the client after it is deleted. + base::WeakPtrFactory<HostUserInterface> weak_factory_; + base::WeakPtr<HostUserInterface> weak_ptr_; DISALLOW_COPY_AND_ASSIGN(HostUserInterface); }; diff --git a/remoting/host/it2me_host_user_interface.cc b/remoting/host/it2me_host_user_interface.cc index c39f6d3..1b2f392 100644 --- a/remoting/host/it2me_host_user_interface.cc +++ b/remoting/host/it2me_host_user_interface.cc @@ -24,29 +24,15 @@ static const int kContinueWindowHideTimeoutMs = 60 * 1000; namespace remoting { -class It2MeHostUserInterface::TimerTask { - public: - TimerTask(base::MessageLoopProxy* message_loop, - const base::Closure& task, - int delay_ms) - : thread_proxy_(message_loop) { - thread_proxy_.PostDelayedTask(FROM_HERE, task, delay_ms); - } - - private: - ScopedThreadProxy thread_proxy_; -}; - - It2MeHostUserInterface::It2MeHostUserInterface(ChromotingHostContext* context) - : HostUserInterface(context) { + : HostUserInterface(context), + ALLOW_THIS_IN_INITIALIZER_LIST(timer_weak_factory_(this)) { } It2MeHostUserInterface::~It2MeHostUserInterface() { DCHECK(ui_message_loop()->BelongsToCurrentThread()); ShowContinueWindow(false); - StartContinueWindowTimer(false); } void It2MeHostUserInterface::Start(ChromotingHost* host, @@ -103,7 +89,6 @@ void It2MeHostUserInterface::ContinueSession(bool continue_session) { if (continue_session) { get_host()->PauseSession(false); - timer_task_.reset(); StartContinueWindowTimer(true); } else { DisconnectSession(); @@ -116,11 +101,13 @@ void It2MeHostUserInterface::OnContinueWindowTimer() { get_host()->PauseSession(true); ShowContinueWindow(true); - timer_task_.reset(new TimerTask( - ui_message_loop(), + // Cancel any pending timer and post one to hide the continue window. + timer_weak_factory_.InvalidateWeakPtrs(); + ui_message_loop()->PostDelayedTask( + FROM_HERE, base::Bind(&It2MeHostUserInterface::OnShutdownHostTimer, - base::Unretained(this)), - kContinueWindowHideTimeoutMs)); + timer_weak_factory_.GetWeakPtr()), + kContinueWindowHideTimeoutMs); } void It2MeHostUserInterface::OnShutdownHostTimer() { @@ -144,14 +131,14 @@ void It2MeHostUserInterface::ShowContinueWindow(bool show) { void It2MeHostUserInterface::StartContinueWindowTimer(bool start) { DCHECK(ui_message_loop()->BelongsToCurrentThread()); + // Abandon previous timer events by invalidating their weak pointer to us. + timer_weak_factory_.InvalidateWeakPtrs(); if (start) { - timer_task_.reset(new TimerTask( - ui_message_loop(), + ui_message_loop()->PostDelayedTask( + FROM_HERE, base::Bind(&It2MeHostUserInterface::OnContinueWindowTimer, - base::Unretained(this)), - kContinueWindowShowTimeoutMs)); - } else { - timer_task_.reset(); + timer_weak_factory_.GetWeakPtr()), + kContinueWindowShowTimeoutMs); } } diff --git a/remoting/host/it2me_host_user_interface.h b/remoting/host/it2me_host_user_interface.h index b054c65..71619ea 100644 --- a/remoting/host/it2me_host_user_interface.h +++ b/remoting/host/it2me_host_user_interface.h @@ -11,6 +11,7 @@ #include "base/callback.h" #include "base/compiler_specific.h" #include "base/memory/scoped_ptr.h" +#include "base/memory/weak_ptr.h" #include "remoting/host/host_user_interface.h" @@ -67,8 +68,9 @@ class It2MeHostUserInterface : public HostUserInterface { // the connection. scoped_ptr<ContinueWindow> continue_window_; - // Timer controlling the "continue session" dialog. - scoped_ptr<TimerTask> timer_task_; + // Weak pointer factory used to abandon the "continue session" timer when + // hiding the "continue session" dialog, or tearing down the IT2Me UI. + base::WeakPtrFactory<It2MeHostUserInterface> timer_weak_factory_; DISALLOW_COPY_AND_ASSIGN(It2MeHostUserInterface); }; diff --git a/remoting/remoting.gyp b/remoting/remoting.gyp index 2d4648b..4485937 100644 --- a/remoting/remoting.gyp +++ b/remoting/remoting.gyp @@ -1043,8 +1043,6 @@ 'base/rate_counter.h', 'base/running_average.cc', 'base/running_average.h', - 'base/scoped_thread_proxy.cc', - 'base/scoped_thread_proxy.h', 'base/util.cc', 'base/util.h', ], |