Remote assistance on Chrome OS Part IV - It2MeHost

remoting/host/policy_hack/policy_watcher.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.
 
 // Most of this code is copied from:
 //   src/chrome/browser/policy/asynchronous_policy_loader.{h,cc}
 
 #include "remoting/host/policy_hack/policy_watcher.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
-#include "base/synchronization/waitable_event.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "remoting/host/dns_blackhole_checker.h"
 
 #if !defined(NDEBUG)
 #include "base/json/json_reader.h"
 #endif
 
 namespace remoting {
 namespace policy_hack {
@@ skipping 132 matching lines @@
                            base::Bind(&PolicyWatcher::StartWatching,
                                       base::Unretained(this),
                                       policy_callback));
     return;
   }
 
   policy_callback_ = policy_callback;
   StartWatchingInternal();
 }
 
-void PolicyWatcher::StopWatching(base::WaitableEvent* done) {
+void PolicyWatcher::StopWatching(const base::Closure& stopped_callback) {
   if (!OnPolicyWatcherThread()) {

[Wez, 2014/10/17 17:58:01]

This kind of trampoline doesn't need a separate function to call on to; you can
just post the task if you're on the wrong thread and Bind() it back to
StopWatching, as this code did previously.

If you really want to use PostTaskAndReply then you may as well always post, to
avoid overcomplicating this method.

[kelvinp, 2014/10/20 00:21:18]

I use PostTaskAndReply as I want the callback is be invoked on the caller
thread.  I will make it always post instead.

-    task_runner_->PostTask(FROM_HERE,
-                           base::Bind(&PolicyWatcher::StopWatching,
-                                      base::Unretained(this), done));
+    task_runner_->PostTaskAndReply(
+        FROM_HERE,
+        base::Bind(&PolicyWatcher::StopWatchingOnPolicyWatcherThread,
+                   base::Unretained(this)),
+        stopped_callback);
     return;
   }
+  StopWatchingOnPolicyWatcherThread();
+  stopped_callback.Run();
+}
 
+void PolicyWatcher::StopWatchingOnPolicyWatcherThread() {
   StopWatchingInternal();
   weak_factory_.InvalidateWeakPtrs();
   policy_callback_.Reset();
-
-  done->Signal();
 }
 
 void PolicyWatcher::ScheduleFallbackReloadTask() {
   DCHECK(OnPolicyWatcherThread());
   ScheduleReloadTask(
       base::TimeDelta::FromMinutes(kFallbackReloadDelayMinutes));
 }
 
 void PolicyWatcher::ScheduleReloadTask(const base::TimeDelta& delay) {
   DCHECK(OnPolicyWatcherThread());
@@ skipping 37 matching lines @@
   old_policies_.swap(new_policies);
 
   // Notify our client of the changed policies.
   if (!changed_policies->empty()) {
     policy_callback_.Run(changed_policies.Pass());
   }
 }
 
 }  // namespace policy_hack
 }  // namespace remoting