Handle automation server crashes.

chrome_frame/test/mock_ie_event_sink_test.h

 // Copyright (c) 2010 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 CHROME_FRAME_TEST_MOCK_IE_EVENT_SINK_TEST_H_
 #define CHROME_FRAME_TEST_MOCK_IE_EVENT_SINK_TEST_H_
 
 #include <atlbase.h>
 #include <atlcom.h>
 #include <string>
@@ skipping 96 matching lines @@
   void ExpectJavascriptWindowOpenNavigation(bool parent_cf, bool new_window_cf,
                                             const std::wstring& url);
 
   // Expect a new window to open. The new event sink will be attached to
   // |new_window_mock|.
   void ExpectNewWindow(MockIEEventSink* new_window_mock);
 
   // Expects any and all navigations.
   void ExpectAnyNavigations();
 
+  void ExpectDocumentReadystate(int ready_state);
+
   IEEventSink* event_sink() { return event_sink_; }
 
  private:
   // Override IE's OnDocumentComplete to call our OnLoad, iff it is IE actually
   // rendering the page.
   virtual void OnDocumentComplete(IDispatch* dispatch, VARIANT* url) {
     if (!event_sink_->IsCFRendering())
       OnLoad(IN_IE, V_BSTR(url));
   }
 
@@ skipping 13 matching lines @@
 
   // It may be necessary to create this on the heap. Otherwise, if the
   // reference count is greater than zero, a debug assert will be triggered
   // in the destructor. This happens at least when IE crashes. In that case,
   // DispEventUnadvise and CoDisconnectObject are not sufficient to decrement
   // the reference count.
   // TODO(kkania): Investigate if the above is true.
   CComObject<IEEventSink>* event_sink_;
 };
 
+// This mocks a PropertyNotifySinkListener, providing methods for
+// expecting certain sequences of events.
+class MockPropertyNotifySinkListener : public PropertyNotifySinkListener {
+ public:
+  MockPropertyNotifySinkListener() : cookie_(0), sink_(NULL) {
+    CComObject<PropertyNotifySinkImpl>::CreateInstance(&sink_);
+    sink_->AddRef();
+    sink_->set_listener(this);
+  }
+
+  ~MockPropertyNotifySinkListener() {
+    Detach();
+    sink_->set_listener(NULL);
+    DLOG_IF(ERROR, sink_->m_dwRef != 1)
+        << "Event sink is still referenced externally: ref count = "
+        << sink_->m_dwRef;
+    sink_->Release();
+  }
+
+  // Override PropertyNotifySinkListener methods.
+  MOCK_METHOD1(OnChanged, void (DISPID dispid));  // NOLINT
+
+  bool Attach(IUnknown* obj) {
+    DCHECK_EQ(cookie_, 0UL);
+    DCHECK(obj);
+    HRESULT hr = AtlAdvise(obj, sink_->GetUnknown(), IID_IPropertyNotifySink,
+                           &cookie_);
+    if (SUCCEEDED(hr)) {
+      event_source_ = obj;
+    } else {
+      LOG(ERROR) << StringPrintf("AtlAdvise: 0x%08X", hr);
+      cookie_ = 0;
+    }
+
+    return SUCCEEDED(hr);
+  }
+
+  void Detach() {
+    if (event_source_) {
+      DCHECK_NE(cookie_, 0UL);
+      AtlUnadvise(event_source_, IID_IPropertyNotifySink, cookie_);
+      event_source_.Release();
+      cookie_ = 0;
+    }
+  }
+
+ private:
+  CComObject<PropertyNotifySinkImpl>* sink_;
+  DWORD cookie_;
+  ScopedComPtr<IUnknown> event_source_;
+};
+
+
 // Mocks a window observer so that tests can detect new windows.
 class MockWindowObserver : public WindowObserver {
  public:
   // Override WindowObserver methods.
   MOCK_METHOD2(OnWindowDetected, void (HWND hwnd,  // NOLINT
                                        const std::string& caption));
 
   // Watch for all windows of the given class type.
   void WatchWindow(const wchar_t* window_class) {
     DCHECK(window_class);
@@ skipping 64 matching lines @@
   testing::StrictMock<MockIEEventSink> ie_mock_;
   testing::StrictMock<MockWebServer> server_mock_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockIEEventSinkTest);
 };
 
 }  // namespace chrome_frame_test
 
 #endif  // CHROME_FRAME_TEST_MOCK_IE_EVENT_SINK_TEST_H_