Support dragging a virtual file out of the browser.

base/message_loop_unittest.cc

 // Copyright (c) 2006-2008 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 "base/logging.h"
 #include "base/message_loop.h"
 #include "base/platform_thread.h"
 #include "base/ref_counted.h"
 #include "base/thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 1089 matching lines @@
 
 #if defined(OS_WIN)
 
 class DispatcherImpl : public MessageLoopForUI::Dispatcher {
  public:
   DispatcherImpl() : dispatch_count_(0) {}
 
   virtual bool Dispatch(const MSG& msg) {
     ::TranslateMessage(&msg);
     ::DispatchMessage(&msg);
-    return (++dispatch_count_ != 2);
+    // Do not count WM_TIMER since it is not what we post and it will cause
+    // flakiness.
+    if (msg.message != WM_TIMER)
+      ++dispatch_count_;
+    // We treat WM_LBUTTONUP as the last message.
+    return msg.message != WM_LBUTTONUP;
   }
 
   int dispatch_count_;
 };
 
 void RunTest_Dispatcher(MessageLoop::Type message_loop_type) {
   MessageLoop loop(message_loop_type);
 
   class MyTask : public Task {
   public:
     virtual void Run() {
       PostMessage(NULL, WM_LBUTTONDOWN, 0, 0);
       PostMessage(NULL, WM_LBUTTONUP, 'A', 0);
     }
   };
   Task* task = new MyTask();
   MessageLoop::current()->PostDelayedTask(FROM_HERE, task, 100);
   DispatcherImpl dispatcher;
   MessageLoopForUI::current()->Run(&dispatcher);
   ASSERT_EQ(2, dispatcher.dispatch_count_);
 }
 
+LRESULT CALLBACK MsgFilterProc(int code, WPARAM wparam, LPARAM lparam) {
+  if (code == base::MessagePumpForUI::kMessageFilterCode) {
+    MSG* msg = reinterpret_cast<MSG*>(lparam);
+    if (msg->message == WM_LBUTTONDOWN)
+      return TRUE;
+  }
+  return FALSE;
+}
+
+void RunTest_DispatcherWithMessageHook(MessageLoop::Type message_loop_type) {
+  MessageLoop loop(message_loop_type);
+
+  class MyTask : public Task {
+  public:
+    virtual void Run() {
+      PostMessage(NULL, WM_LBUTTONDOWN, 0, 0);
+      PostMessage(NULL, WM_LBUTTONUP, 'A', 0);
+    }
+  };
+  Task* task = new MyTask();
+  MessageLoop::current()->PostDelayedTask(FROM_HERE, task, 100);
+  HHOOK msg_hook = SetWindowsHookEx(WH_MSGFILTER,
+                                    MsgFilterProc,
+                                    NULL,
+                                    GetCurrentThreadId());
+  DispatcherImpl dispatcher;
+  MessageLoopForUI::current()->Run(&dispatcher);
+  ASSERT_EQ(1, dispatcher.dispatch_count_);
+  UnhookWindowsHookEx(msg_hook);
+}
+
 class TestIOHandler : public MessageLoopForIO::IOHandler {
  public:
   TestIOHandler(const wchar_t* name, HANDLE signal, bool wait);
 
   virtual void OnIOCompleted(MessageLoopForIO::IOContext* context,
                              DWORD bytes_transfered, DWORD error);
 
   void Init();
   void WaitForIO();
   OVERLAPPED* context() { return &context_.overlapped; }
@@ skipping 273 matching lines @@
   RunTest_NonNestableInNestedLoop(MessageLoop::TYPE_UI, true);
   RunTest_NonNestableInNestedLoop(MessageLoop::TYPE_IO, true);
 }
 
 #if defined(OS_WIN)
 TEST(MessageLoopTest, Dispatcher) {
   // This test requires a UI loop
   RunTest_Dispatcher(MessageLoop::TYPE_UI);
 }
 
+TEST(MessageLoopTest, DispatcherWithMessageHook) {
+  // This test requires a UI loop
+  RunTest_DispatcherWithMessageHook(MessageLoop::TYPE_UI);
+}
+
 TEST(MessageLoopTest, IOHandler) {
   RunTest_IOHandler();
 }
 
 TEST(MessageLoopTest, WaitForIO) {
   RunTest_WaitForIO();
 }
 #endif  // defined(OS_WIN)
 
 #if defined(OS_POSIX)
@@ skipping 60 matching lines @@
       message_loop.WatchFileDescriptor(fd,
           true, MessageLoopForIO::WATCH_WRITE, &controller, &delegate);
       controller.StopWatchingFileDescriptor();
     }
   }
   close(pipefds[0]);
   close(pipefds[1]);
 }
 
 #endif  // defined(OS_POSIX)