1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "base/win/object_watcher.h"
6
7 #include "base/bind.h"
8 #include "base/logging.h"
9
10 namespace base {
11 namespace win {
12
13 //-----------------------------------------------------------------------------
14
ObjectWatcher()15 ObjectWatcher::ObjectWatcher()
16 : object_(NULL),
17 wait_object_(NULL),
18 origin_loop_(NULL),
19 weak_factory_(this) {
20 }
21
~ObjectWatcher()22 ObjectWatcher::~ObjectWatcher() {
23 StopWatching();
24 }
25
StartWatching(HANDLE object,Delegate * delegate)26 bool ObjectWatcher::StartWatching(HANDLE object, Delegate* delegate) {
27 CHECK(delegate);
28 if (wait_object_) {
29 NOTREACHED() << "Already watching an object";
30 return false;
31 }
32
33 // Since our job is to just notice when an object is signaled and report the
34 // result back to this thread, we can just run on a Windows wait thread.
35 DWORD wait_flags = WT_EXECUTEINWAITTHREAD | WT_EXECUTEONLYONCE;
36
37 // DoneWaiting can be synchronously called from RegisterWaitForSingleObject,
38 // so set up all state now.
39 callback_ = base::Bind(&ObjectWatcher::Signal, weak_factory_.GetWeakPtr(),
40 delegate);
41 object_ = object;
42 origin_loop_ = MessageLoop::current();
43
44 if (!RegisterWaitForSingleObject(&wait_object_, object, DoneWaiting,
45 this, INFINITE, wait_flags)) {
46 DPLOG(FATAL) << "RegisterWaitForSingleObject failed";
47 object_ = NULL;
48 wait_object_ = NULL;
49 return false;
50 }
51
52 // We need to know if the current message loop is going away so we can
53 // prevent the wait thread from trying to access a dead message loop.
54 MessageLoop::current()->AddDestructionObserver(this);
55 return true;
56 }
57
StopWatching()58 bool ObjectWatcher::StopWatching() {
59 if (!wait_object_)
60 return false;
61
62 // Make sure ObjectWatcher is used in a single-threaded fashion.
63 DCHECK_EQ(origin_loop_, MessageLoop::current());
64
65 // Blocking call to cancel the wait. Any callbacks already in progress will
66 // finish before we return from this call.
67 if (!UnregisterWaitEx(wait_object_, INVALID_HANDLE_VALUE)) {
68 DPLOG(FATAL) << "UnregisterWaitEx failed";
69 return false;
70 }
71
72 weak_factory_.InvalidateWeakPtrs();
73 object_ = NULL;
74 wait_object_ = NULL;
75
76 MessageLoop::current()->RemoveDestructionObserver(this);
77 return true;
78 }
79
GetWatchedObject()80 HANDLE ObjectWatcher::GetWatchedObject() {
81 return object_;
82 }
83
84 // static
DoneWaiting(void * param,BOOLEAN timed_out)85 void CALLBACK ObjectWatcher::DoneWaiting(void* param, BOOLEAN timed_out) {
86 DCHECK(!timed_out);
87
88 // The destructor blocks on any callbacks that are in flight, so we know that
89 // that is always a pointer to a valid ObjectWater.
90 ObjectWatcher* that = static_cast<ObjectWatcher*>(param);
91 that->origin_loop_->PostTask(FROM_HERE, that->callback_);
92 that->callback_.Reset();
93 }
94
Signal(Delegate * delegate)95 void ObjectWatcher::Signal(Delegate* delegate) {
96 // Signaling the delegate may result in our destruction or a nested call to
97 // StartWatching(). As a result, we save any state we need and clear previous
98 // watcher state before signaling the delegate.
99 HANDLE object = object_;
100 StopWatching();
101 delegate->OnObjectSignaled(object);
102 }
103
WillDestroyCurrentMessageLoop()104 void ObjectWatcher::WillDestroyCurrentMessageLoop() {
105 // Need to shutdown the watch so that we don't try to access the MessageLoop
106 // after this point.
107 StopWatching();
108 }
109
110 } // namespace win
111 } // namespace base
112