Not using std::wstring to store progress status text because mshtml is sensit...

chrome_frame/urlmon_bind_status_callback.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_URLMON_BIND_STATUS_CALLBACK_H_
 #define CHROME_FRAME_URLMON_BIND_STATUS_CALLBACK_H_
 
 #include <atlbase.h>
 #include <atlcom.h>
 
@@ skipping 75 matching lines @@
   bool eof_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SniffData);
 };
 
 // A wrapper for bind status callback in IMoniker::BindToStorage
 class BSCBStorageBind : public BSCBImpl {
  public:
   typedef BSCBImpl CallbackImpl;
-  BSCBStorageBind() : clip_format_(CF_NULL) {}
+  BSCBStorageBind();
+  ~BSCBStorageBind();
 
 BEGIN_COM_MAP(BSCBStorageBind)
   COM_INTERFACE_ENTRY(IBindStatusCallback)
   COM_INTERFACE_ENTRY_CHAIN(CallbackImpl)
 END_COM_MAP()
 
   HRESULT Initialize(IMoniker* moniker, IBindCtx* bind_ctx);
   HRESULT MayPlayBack(DWORD flags);
 
   // IBindStatusCallback
   STDMETHOD(OnProgress)(ULONG progress, ULONG progress_max, ULONG status_code,
                         LPCWSTR status_text);
   STDMETHOD(OnDataAvailable)(DWORD flags, DWORD size, FORMATETC* format_etc,
                              STGMEDIUM* stgmed);
   STDMETHOD(OnStopBinding)(HRESULT hresult, LPCWSTR error);
 
  protected:
   // is it a good time to start caching progress notifications
   bool ShouldCacheProgress(ULONG status_code) const;
 
  protected:
   SniffData data_sniffer_;
 
-  // A structure to cache the progress notifications
-  struct Progress {
+  // A structure to cache the progress notifications.
+  class Progress {
+   public:
+    Progress(ULONG progress, ULONG progress_max, ULONG status_code,
+             const wchar_t* status_text)
+        : progress_(progress),
+          progress_max_(progress_max),
+          status_code_(status_code),
+          status_text_(NULL) {
+      if (status_text) {
+        int len = lstrlenW(status_text) + 1;
+        status_text_ = reinterpret_cast<wchar_t*>(
+            ::CoTaskMemAlloc(len * sizeof(wchar_t)));
+        if (status_text_) {
+          lstrcpyW(status_text_, status_text);
+        } else {
+          NOTREACHED();
+        }
+      }
+    }
+
+    ~Progress() {
+      if (status_text_) {
+        ::CoTaskMemFree(status_text_);
+      }
+    }
+
+    ULONG progress() const {
+      return progress_;
+    }
+
+    ULONG progress_max() const {
+      return progress_max_;
+    }
+
+    ULONG status_code() const {
+      return status_code_;
+    }
+
+    const wchar_t* status_text() const {
+      return status_text_;
+    }
+
+   protected:
     ULONG progress_;
     ULONG progress_max_;
     ULONG status_code_;
-    std::wstring status_text_;
+    // We don't use std::wstring here since we want to be able to play
+    // progress notifications back exactly as we got them.  NULL and L"" are
+    // not equal.
+    wchar_t* status_text_;
   };
 
-  std::vector<Progress> saved_progress_;
+  std::vector<Progress*> saved_progress_;
   CLIPFORMAT clip_format_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BSCBStorageBind);
 };
 
 #endif  // CHROME_FRAME_URLMON_BIND_STATUS_CALLBACK_H_