Home | History | Annotate | Download | only in WebCoreSupport 
      1 /*
      2  * Copyright 2010, The Android Open Source Project
      3  *
      4  * Redistribution and use in source and binary forms, with or without
      5  * modification, are permitted provided that the following conditions
      6  * are met:
      7  *  * Redistributions of source code must retain the above copyright
      8  *    notice, this list of conditions and the following disclaimer.
      9  *  * Redistributions in binary form must reproduce the above copyright
     10  *    notice, this list of conditions and the following disclaimer in the
     11  *    documentation and/or other materials provided with the distribution.
     12  *
     13  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
     14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
     17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
     18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
     19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
     20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
     21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     24  */
     25 
     26 #ifndef WebUrlLoaderClient_h
     27 #define WebUrlLoaderClient_h
     28 
     29 #include "ChromiumIncludes.h"
     30 #include "RefCounted.h"
     31 #include "WebResponse.h"
     32 #include "WebUrlLoader.h"
     33 
     34 #include <string>
     35 #include <deque>
     36 #include <string>
     37 #include <vector>
     38 
     39 
     40 namespace base {
     41 class ConditionVariable;
     42 class Lock;
     43 class Thread;
     44 }
     45 
     46 namespace net {
     47 class IOBuffer;
     48 class AuthChallengeInfo;
     49 }
     50 
     51 namespace android {
     52 
     53 class WebFrame;
     54 class WebRequest;
     55 class WebRequestContext;
     56 
     57 // This class handles communication between the IO thread where loading happens
     58 // and the webkit main thread.
     59 // TODO:
     60 // - Implement didFail
     61 // - Implement sync requests
     62 // - Implement downloadFile
     63 // - Implement pauseLoad
     64 class WebUrlLoaderClient : public base::RefCountedThreadSafe<WebUrlLoaderClient> {
     65 public:
     66     WebUrlLoaderClient(WebFrame*, WebCore::ResourceHandle*, const WebCore::ResourceRequest&);
     67 
     68     // Called from WebCore, will be forwarded to the IO thread
     69     bool start(bool isMainResource, bool isMainFrame, bool sync, WebRequestContext*);
     70     void cancel();
     71     void downloadFile();
     72     void pauseLoad(bool pause);
     73     void setAuth(const std::string& username, const std::string& password);
     74     void cancelAuth();
     75     void proceedSslCertError();
     76     void cancelSslCertError(int cert_error);
     77 
     78     typedef void CallbackFunction(void*);
     79 
     80     // This is called from the IO thread, and dispatches the callback to the main thread.
     81     // (For asynchronous calls, we just delegate to WebKit's callOnMainThread.)
     82     void maybeCallOnMainThread(Task* task);
     83 
     84     // Called by WebRequest (using maybeCallOnMainThread), should be forwarded to WebCore.
     85     void didReceiveResponse(PassOwnPtr<WebResponse>);
     86     void didReceiveData(scoped_refptr<net::IOBuffer>, int size);
     87     void didReceiveDataUrl(PassOwnPtr<std::string>);
     88     void didReceiveAndroidFileData(PassOwnPtr<std::vector<char> >);
     89     void didFinishLoading();
     90     void didFail(PassOwnPtr<WebResponse>);
     91     void willSendRequest(PassOwnPtr<WebResponse>);
     92     void authRequired(scoped_refptr<net::AuthChallengeInfo>, bool firstTime, bool suppressDialog);
     93     void reportSslCertError(int cert_error, net::X509Certificate* cert);
     94 
     95     void sslClientCert(EVP_PKEY* pkey, net::X509Certificate* chain);
     96     void requestClientCert(net::SSLCertRequestInfo* cert);
     97 
     98     // Handle to the chrome IO thread
     99     static base::Thread* ioThread();
    100 
    101 private:
    102     friend class base::RefCountedThreadSafe<WebUrlLoaderClient>;
    103     virtual ~WebUrlLoaderClient();
    104 
    105     void finish();
    106 
    107     WebFrame* m_webFrame;
    108     RefPtr<WebCore::ResourceHandle> m_resourceHandle;
    109     bool m_isMainResource;
    110     bool m_isMainFrame;
    111     bool m_isCertMimeType;
    112     bool m_cancelling;
    113     bool m_sync;
    114     volatile bool m_finished;
    115 
    116     scoped_refptr<WebRequest> m_request;
    117     OwnPtr<WebResponse> m_response; // NULL until didReceiveResponse is called.
    118 
    119     // Check if a request is active
    120     bool isActive() const;
    121 
    122     // Mutex and condition variable used for synchronous requests.
    123     // Note that these are static. This works because there's only one main thread.
    124     static base::Lock* syncLock();
    125     static base::ConditionVariable* syncCondition();
    126 
    127     // Queue of callbacks to be executed by the main thread. Must only be accessed inside mutex.
    128     std::deque<Task*> m_queue;
    129 };
    130 
    131 } // namespace android
    132 
    133 #endif
    134