Transfer CF downloads to the host browser....

chrome_frame/chrome_frame_activex_base.h

 // Copyright (c) 2009 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_CHROME_FRAME_ACTIVEX_BASE_H_
 #define CHROME_FRAME_CHROME_FRAME_ACTIVEX_BASE_H_
 
 #include <atlbase.h>
 #include <atlcom.h>
 #include <atlctl.h>
 
 // Copied min/max defs from windows headers to appease atlimage.h.
 // TODO(slightlyoff): Figure out of more recent platform SDK's (> 6.1)
 //   undo the janky "#define NOMINMAX" train wreck. See:
 // http://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=100703
 #ifndef max
-#define max(a,b) (((a) > (b)) ? (a) : (b))
+#define max(a,b) (((a) > (b)) ? (a) : (b))  // NOLINT
 #endif
 #ifndef min
-#define min(a,b) (((a) < (b)) ? (a) : (b))
+#define min(a,b) (((a) < (b)) ? (a) : (b))  // NOLINT
 #endif
 #include <atlimage.h>
 #undef max
 #undef min
 
 #include <shdeprecated.h>  // for IBrowserService2
 #include <shlguid.h>
 
 #include <set>
 #include <string>
@@ skipping 61 matching lines @@
     var.pdispVal = event;
     FireMethodWithParam(CF_EVENT_DISPID_ONLOADERROR, var);
   }
 
   void Fire_onmessage(IDispatch* event) {
     VARIANT var = { VT_DISPATCH };
     var.pdispVal = event;
     FireMethodWithParam(CF_EVENT_DISPID_ONMESSAGE, var);
   }
 
-  void Fire_onreadystatechanged(long readystate) {
+  void Fire_onreadystatechanged(long readystate) {  // NOLINT
     VARIANT var = { VT_I4 };
     var.lVal = readystate;
     FireMethodWithParam(CF_EVENT_DISPID_ONREADYSTATECHANGED, var);
   }
 
   void Fire_onprivatemessage(IDispatch* event, BSTR target) {
     // Arguments in reverse order to the function declaration, because
     // that's what DISPPARAMS requires.
     VARIANT args[2] = { { VT_BSTR, }, {VT_DISPATCH, } };
     args[0].bstrVal = target;
     args[1].pdispVal = event;
 
     FireMethodWithParams(CF_EVENT_DISPID_ONPRIVATEMESSAGE,
                          args,
                          arraysize(args));
   }
 
-  void Fire_onextensionready(BSTR path, long response) {
+  void Fire_onextensionready(BSTR path, long response) {  // NOLINT
     // Arguments in reverse order to the function declaration, because
     // that's what DISPPARAMS requires.
     VARIANT args[2] = { { VT_I4, }, { VT_BSTR, } };
     args[0].lVal = response;
     args[1].bstrVal = path;
 
     FireMethodWithParams(CF_EVENT_DISPID_ONEXTENSIONREADY,
                          args,
                          arraysize(args));
   }
 };
 
 extern bool g_first_launch_by_process_;
 
 // Common implementation for ActiveX and Active Document
 template <class T, const CLSID& class_id>
-class ATL_NO_VTABLE ChromeFrameActivexBase :
+class ATL_NO_VTABLE ChromeFrameActivexBase :  // NOLINT
   public CComObjectRootEx<CComMultiThreadModel>,
   public IOleControlImpl<T>,
   public IOleObjectImpl<T>,
   public IOleInPlaceActiveObjectImpl<T>,
   public IViewObjectExImpl<T>,
   public IOleInPlaceObjectWindowlessImpl<T>,
   public ISupportErrorInfo,
   public IQuickActivateImpl<T>,
   public com_util::IProvideClassInfo2Impl<class_id,
                                           DIID_DIChromeFrameEvents>,
@@ skipping 111 matching lines @@
     };
 
     for (int i = 0; i < arraysize(interfaces); ++i) {
       if (InlineIsEqualGUID(*interfaces[i], riid))
         return S_OK;
     }
     return S_FALSE;
   }
 
   // Called to draw our control when chrome hasn't been initialized.
-  virtual HRESULT OnDraw(ATL_DRAWINFO& draw_info) {  // NO_LINT
+  virtual HRESULT OnDraw(ATL_DRAWINFO& draw_info) {  // NOLINT
     if (NULL == draw_info.prcBounds) {
       NOTREACHED();
       return E_FAIL;
     }
     // Don't draw anything.
     return S_OK;
   }
 
 
   // Used to setup the document_url_ member needed for completing navigation.
@@ skipping 203 matching lines @@
     automation_client_->ReadRequest(request_id, bytes_to_read);
   }
 
   virtual void OnRequestEnd(int tab_handle, int request_id,
                             const URLRequestStatus& status) {
     automation_client_->RemoveRequest(request_id, true);
   }
 
   virtual void OnDownloadRequestInHost(int tab_handle, int request_id) {
     DLOG(INFO) << "TODO: Let the host browser handle this download";
+    PluginUrlRequest* request = automation_client_->LookupRequest(request_id);
+    if (request) {
+      static_cast<UrlmonUrlRequest*>(request)->TransferToHost(doc_site_);
+    }
     automation_client_->RemoveRequest(request_id, false);
   }
 
   virtual void OnSetCookieAsync(int tab_handle, const GURL& url,
                                 const std::string& cookie) {
     std::string name;
     std::string data;
     size_t name_end = cookie.find('=');
     if (std::string::npos != name_end) {
       name = cookie.substr(0, name_end);
@@ skipping 404 matching lines @@
     }
 
     return hr;
   }
 
   // Creates a new event object that supports the |data| property.
   // Note: you should supply an empty string for |origin| unless you're
   // creating a "message" event.
   HRESULT CreateDomEvent(const std::string& event_type, const std::string& data,
                          const std::string& origin, IDispatch** event) {
-    DCHECK(event_type.length() > 0);
+    DCHECK(event_type.length() > 0);  // NOLINT
     DCHECK(event != NULL);
 
     CComObject<ComMessageEvent>* ev = NULL;
     HRESULT hr = CComObject<ComMessageEvent>::CreateInstance(&ev);
     if (SUCCEEDED(hr)) {
       ev->AddRef();
 
       ScopedComPtr<IOleContainer> container;
       m_spClientSite->GetContainer(container.Receive());
       if (ev->Initialize(container, data, origin, event_type)) {
@@ skipping 14 matching lines @@
     ScopedVariant script_arg(UTF8ToWide(param.c_str()).c_str());
     return InvokeScriptFunction(script_object, script_arg.AsInput());
   }
 
   HRESULT InvokeScriptFunction(const VARIANT& script_object, VARIANT* param) {
     return InvokeScriptFunction(script_object, param, 1);
   }
 
   HRESULT InvokeScriptFunction(const VARIANT& script_object, VARIANT* params,
                                int param_count) {
-    DCHECK(param_count >= 0);
+    DCHECK_GE(param_count, 0);
     DCHECK(params);
 
     if (V_VT(&script_object) != VT_DISPATCH) {
       return S_FALSE;
     }
 
     CComPtr<IDispatch> script(script_object.pdispVal);
     HRESULT hr = script.InvokeN(static_cast<DISPID>(DISPID_VALUE),
                                 params,
                                 param_count);
@@ skipping 92 matching lines @@
     // should have first dibs anyway.
     if (hr != S_OK && automation_client_.get()) {
       TabProxy* tab = automation_client_->tab();
       if (tab) {
         tab->ProcessUnhandledAccelerator(accel_message);
       }
     }
   }
 
  protected:
-   // The following functions are called to initialize and uninitialize the
-   // worker thread.
-   void OnWorkerStart() {
-     CoInitialize(NULL);
-   }
+  // The following functions are called to initialize and uninitialize the
+  // worker thread.
+  void OnWorkerStart() {
+    CoInitialize(NULL);
+  }
 
-   void OnWorkerStop() {
-     CoUninitialize();
-   }
+  void OnWorkerStop() {
+    CoUninitialize();
+  }
 
   ScopedBstr url_;
   ScopedComPtr<IOleDocumentSite> doc_site_;
 
   // For more information on the ready_state_ property see:
   // http://msdn.microsoft.com/en-us/library/aa768179(VS.85).aspx#
   READYSTATE ready_state_;
 
   // The following members contain IDispatch interfaces representing the
   // onload/onerror/onmessage handlers on the page.
   ScopedVariant onload_handler_;
   ScopedVariant onerror_handler_;
   ScopedVariant onmessage_handler_;
 
   EventHandlers onmessage_;
   EventHandlers onloaderror_;
   EventHandlers onload_;
   EventHandlers onreadystatechanged_;
   EventHandlers onprivatemessage_;
   EventHandlers onextensionready_;
 
   // The UrlmonUrlRequest instance instantiated for downloading the base URL.
   scoped_refptr<CComObject<UrlmonUrlRequest> > base_url_request_;
 
   base::Thread worker_thread_;
 };
 
 #endif  // CHROME_FRAME_CHROME_FRAME_ACTIVEX_BASE_H_