Assert that thread-safe reference counting is used with...

chrome_frame/test/chrome_frame_unittests.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 <windows.h>
 #include <stdarg.h>
 
 // IShellWindows includes.  Unfortunately we can't keep these in
 // alphabetic order since exdisp will bark if some interfaces aren't fully
 // defined.
 #include <mshtml.h>
@@ skipping 779 matching lines @@
 }
 
 TEST_F(ChromeFrameTestWithWebServer, WidgetModeOpera_PrivilegedApis) {
   OptionalBrowserTest(OPERA, kPrivilegedApisPage, L"PrivilegedApis");
 }
 
 class ChromeFrameTestEnvironment: public testing::Environment {
   public:
     ~ChromeFrameTestEnvironment() {
     }
-    
+
     void SetUp() {
       ScopedChromeFrameRegistrar::RegisterDefaults();
     }
 
     void TearDown() {
     }
 };
 
 ::testing::Environment* const chrome_frame_env =
     ::testing::AddGlobalTestEnvironment(new ChromeFrameTestEnvironment);
@@ skipping 170 matching lines @@
   void ForwardTo(MockAutomationProxy *p) {
     proxy_ = p;
     ON_CALL(*this, Send(testing::_))
         .WillByDefault(testing::Invoke(proxy_, &MockAutomationProxy::Send));
   }
 
   MockAutomationProxy* proxy_;
 };
 
 template <> struct RunnableMethodTraits<ProxyFactory::LaunchDelegate> {
-  static void RetainCallee(ProxyFactory::LaunchDelegate* obj) {}
-  static void ReleaseCallee(ProxyFactory::LaunchDelegate* obj) {}
+  void RetainCallee(ProxyFactory::LaunchDelegate* obj) {}
+  void ReleaseCallee(ProxyFactory::LaunchDelegate* obj) {}
 };
 
 template <> struct RunnableMethodTraits<MockProxyFactory> {
-  static void RetainCallee(MockProxyFactory* obj) {}
-  static void ReleaseCallee(MockProxyFactory* obj) {}
+  void RetainCallee(MockProxyFactory* obj) {}
+  void ReleaseCallee(MockProxyFactory* obj) {}
 };
 
 template <> struct RunnableMethodTraits<ChromeFrameAutomationClient> {
-  static void RetainCallee(ChromeFrameAutomationClient* obj) {}
-  static void ReleaseCallee(ChromeFrameAutomationClient* obj) {}
+  void RetainCallee(ChromeFrameAutomationClient* obj) {}
+  void ReleaseCallee(ChromeFrameAutomationClient* obj) {}
 };
 
 // MessageLoopForUI wrapper that runs only for a limited time.
 // We need a UI message loop in the main thread.
 struct TimedMsgLoop {
  public:
   void RunFor(int seconds) {
     loop_.PostDelayedTask(FROM_HERE, new MessageLoop::QuitTask, 1000 * seconds);
     loop_.MessageLoop::Run();
   }
 
   void Quit() {
     loop_.PostTask(FROM_HERE, new MessageLoop::QuitTask);
   }
 
   MessageLoopForUI loop_;
 };
 
 template <> struct RunnableMethodTraits<TimedMsgLoop> {
-  static void RetainCallee(TimedMsgLoop* obj) {}
-  static void ReleaseCallee(TimedMsgLoop* obj) {}
+  void RetainCallee(TimedMsgLoop* obj) {}
+  void ReleaseCallee(TimedMsgLoop* obj) {}
 };
 
 // Saves typing. It's somewhat hard to create a wrapper around
 // testing::InvokeWithoutArgs since it returns a
 // non-public (testing::internal) type.
 #define QUIT_LOOP(loop) testing::InvokeWithoutArgs(TaskHolder(\
     NewRunnableMethod(&loop, &TimedMsgLoop::Quit)))
 
 // We mock ChromeFrameDelegate only. The rest is with real AutomationProxy
 TEST(CFACWithChrome, CreateTooFast) {
@@ skipping 467 matching lines @@
   EXPECT_TRUE(hr == S_OK);
 
   web_browser2.Release();
   chrome_frame_test::CloseAllIEWindows();
 
   if (should_uninit) {
     CoUninitialize();
   }
 }