Home | History | Annotate | Download | only in chrome_frame 
      1 // Copyright (c) 2011 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 #ifndef CHROME_FRAME_URLMON_BIND_STATUS_CALLBACK_H_
      6 #define CHROME_FRAME_URLMON_BIND_STATUS_CALLBACK_H_
      7 
      8 #include <atlbase.h>
      9 #include <atlcom.h>
     10 
     11 #include "base/memory/scoped_ptr.h"
     12 #include "chrome_frame/bind_status_callback_impl.h"
     13 #include "chrome_frame/stream_impl.h"
     14 
     15 
     16 // A fake stream class to serve cached data to arbitrary
     17 // IBindStatusCallback
     18 class CacheStream : public CComObjectRoot, public StreamImpl {
     19  public:
     20   BEGIN_COM_MAP(CacheStream)
     21     COM_INTERFACE_ENTRY(IStream)
     22     COM_INTERFACE_ENTRY(ISequentialStream)
     23   END_COM_MAP()
     24 
     25   CacheStream() : size_(0), position_(0), eof_(false) {
     26   }
     27   HRESULT Initialize(const char* cache, size_t size, bool eof);
     28   static HRESULT BSCBFeedData(IBindStatusCallback* bscb, const char* data,
     29                               size_t size, CLIPFORMAT clip_format,
     30                               size_t flags, bool eof);
     31 
     32   // IStream overrides
     33   STDMETHOD(Read)(void* pv, ULONG cb, ULONG* read);
     34 
     35  protected:
     36   scoped_ptr<char[]> cache_;
     37   size_t size_;
     38   size_t position_;
     39   bool eof_;
     40 
     41  private:
     42   DISALLOW_COPY_AND_ASSIGN(CacheStream);
     43 };
     44 
     45 // Utility class for data sniffing
     46 class SniffData {
     47  public:
     48   SniffData() : renderer_type_(OTHER), size_(0), eof_(false) {}
     49 
     50   enum RendererType {
     51     UNDETERMINED,
     52     CHROME,
     53     OTHER
     54   };
     55 
     56   HRESULT InitializeCache(const std::wstring& url);
     57   HRESULT ReadIntoCache(IStream* stream, bool force_determination);
     58   HRESULT DrainCache(IBindStatusCallback* bscb, DWORD bscf,
     59                      CLIPFORMAT clip_format);
     60   void DetermineRendererType(bool last_chance);
     61 
     62   bool is_undetermined() const {
     63     return (UNDETERMINED == renderer_type_);
     64   }
     65   bool is_chrome() const {
     66     return (CHROME == renderer_type_);
     67   }
     68 
     69   RendererType renderer_type() const {
     70     return renderer_type_;
     71   }
     72 
     73   size_t size() const {
     74     return size_;
     75   }
     76 
     77   bool is_cache_valid() {
     78     return (size_ != 0);
     79   }
     80 
     81   base::win::ScopedComPtr<IStream> cache_;
     82   std::wstring url_;
     83   RendererType renderer_type_;
     84   size_t size_;
     85 
     86   static const size_t kMaxSniffSize = 2 * 1024;
     87   bool eof_;
     88 
     89  private:
     90   DISALLOW_COPY_AND_ASSIGN(SniffData);
     91 };
     92 
     93 // A wrapper for bind status callback in IMoniker::BindToStorage
     94 class BSCBStorageBind : public BSCBImpl {
     95  public:
     96   typedef BSCBImpl CallbackImpl;
     97   BSCBStorageBind();
     98   ~BSCBStorageBind();
     99 
    100 BEGIN_COM_MAP(BSCBStorageBind)
    101   COM_INTERFACE_ENTRY(IBindStatusCallback)
    102   COM_INTERFACE_ENTRY_CHAIN(CallbackImpl)
    103 END_COM_MAP()
    104 
    105   HRESULT Initialize(IMoniker* moniker, IBindCtx* bind_ctx);
    106   HRESULT MayPlayBack(DWORD flags);
    107 
    108   // IBindStatusCallback
    109   STDMETHOD(OnProgress)(ULONG progress, ULONG progress_max, ULONG status_code,
    110                         LPCWSTR status_text);
    111   STDMETHOD(OnDataAvailable)(DWORD flags, DWORD size, FORMATETC* format_etc,
    112                              STGMEDIUM* stgmed);
    113   STDMETHOD(OnStopBinding)(HRESULT hresult, LPCWSTR error);
    114 
    115  protected:
    116   // is it a good time to start caching progress notifications
    117   bool ShouldCacheProgress(ULONG status_code) const;
    118 
    119  protected:
    120   SniffData data_sniffer_;
    121 
    122   // A structure to cache the progress notifications.
    123   class Progress {
    124    public:
    125     Progress(ULONG progress, ULONG progress_max, ULONG status_code,
    126              const wchar_t* status_text)
    127         : progress_(progress),
    128           progress_max_(progress_max),
    129           status_code_(status_code) {
    130       if (status_text) {
    131         int len = lstrlenW(status_text) + 1;
    132         status_text_.reset(new wchar_t[len]);
    133         if (status_text_.get()) {
    134           lstrcpynW(status_text_.get(), status_text, len);
    135         } else {
    136           NOTREACHED();
    137         }
    138       }
    139     }
    140 
    141     ~Progress() {
    142     }
    143 
    144     ULONG progress() const {
    145       return progress_;
    146     }
    147 
    148     ULONG progress_max() const {
    149       return progress_max_;
    150     }
    151 
    152     ULONG status_code() const {
    153       return status_code_;
    154     }
    155 
    156     const wchar_t* status_text() const {
    157       return status_text_.get();
    158     }
    159 
    160    protected:
    161     ULONG progress_;
    162     ULONG progress_max_;
    163     ULONG status_code_;
    164     // We don't use std::wstring here since we want to be able to play
    165     // progress notifications back exactly as we got them.  NULL and L"" are
    166     // not equal.
    167     scoped_ptr<wchar_t[]> status_text_;
    168   };
    169 
    170   typedef std::vector<Progress*> ProgressVector;
    171   ProgressVector saved_progress_;
    172   CLIPFORMAT clip_format_;
    173 
    174  private:
    175   DISALLOW_COPY_AND_ASSIGN(BSCBStorageBind);
    176 };
    177 
    178 #endif  // CHROME_FRAME_URLMON_BIND_STATUS_CALLBACK_H_
    179