Merge branch '5.6' into dev

Change-Id: I0bb971f01ee1e02da768f336680c8ec0254ab2b0

1 files changed, 163 insertions, 71 deletions

diff --git a/src/core/url_request_custom_job.cpp b/src/core/url_request_custom_job.cpp
index 5bb29bcc3..f8a47b2b1 100644
--- a/src/core/url_request_custom_job.cpp
+++ b/src/core/url_request_custom_job.cpp
@@ -59,46 +59,33 @@ namespace QtWebEngineCore {
 
 URLRequestCustomJob::URLRequestCustomJob(URLRequest *request, NetworkDelegate *networkDelegate, QWebEngineUrlSchemeHandler *schemeHandler)
     : URLRequestJob(request, networkDelegate)
-    , m_device(0)
     , m_schemeHandler(schemeHandler)
-    , m_error(0)
-    , m_started(false)
-    , m_weakFactoryIO(this)
-    , m_weakFactoryUI(this)
+    , m_shared(new URLRequestCustomJobShared(this))
 {
 }
 
 URLRequestCustomJob::~URLRequestCustomJob()
 {
-    QMutexLocker lock(&m_mutex);
-    if (m_delegate) {
-        m_delegate->m_job = 0;
-        m_delegate->deleteLater();
-    }
-    if (m_device && m_device->isOpen())
-        m_device->close();
+    if (m_shared)
+        m_shared->killJob();
+}
+
+static void startAsync(URLRequestCustomJobShared *shared)
+{
+    shared->startAsync();
 }
 
 void URLRequestCustomJob::Start()
 {
     DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
-    content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE, base::Bind(&URLRequestCustomJob::startAsync, m_weakFactoryIO.GetWeakPtr()));
+    content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE, base::Bind(&startAsync, m_shared));
 }
 
 void URLRequestCustomJob::Kill()
 {
-    DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
-    QMutexLocker lock(&m_mutex);
-    if (m_delegate) {
-        m_delegate->m_job = 0;
-        m_delegate->deleteLater();
-    }
-    m_delegate = 0;
-    if (m_device && m_device->isOpen())
-        m_device->close();
-    m_device = 0;
-    m_weakFactoryIO.InvalidateWeakPtrs();
-    m_weakFactoryUI.InvalidateWeakPtrs();
+    if (m_shared)
+        m_shared->killJob();
+    m_shared = 0;
 
     URLRequestJob::Kill();
 }
@@ -106,8 +93,11 @@ void URLRequestCustomJob::Kill()
 bool URLRequestCustomJob::GetMimeType(std::string *mimeType) const
 {
     DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
-    if (m_mimeType.size() > 0) {
-        *mimeType = m_mimeType;
+    if (!m_shared)
+        return false;
+    QMutexLocker lock(&m_shared->m_mutex);
+    if (m_shared->m_mimeType.size() > 0) {
+        *mimeType = m_shared->m_mimeType;
         return true;
     }
     return false;
@@ -116,8 +106,11 @@ bool URLRequestCustomJob::GetMimeType(std::string *mimeType) const
 bool URLRequestCustomJob::GetCharset(std::string* charset)
 {
     DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
-    if (m_charset.size() > 0) {
-        *charset = m_charset;
+    if (!m_shared)
+        return false;
+    QMutexLocker lock(&m_shared->m_mutex);
+    if (m_shared->m_charset.size() > 0) {
+        *charset = m_shared->m_charset;
         return true;
     }
     return false;
@@ -126,124 +119,223 @@ bool URLRequestCustomJob::GetCharset(std::string* charset)
 bool URLRequestCustomJob::IsRedirectResponse(GURL* location, int* http_status_code)
 {
     DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
-    QMutexLocker lock(&m_mutex);
-    if (m_redirect.is_valid()) {
-        *location = m_redirect;
+    if (!m_shared)
+        return false;
+    QMutexLocker lock(&m_shared->m_mutex);
+    if (m_shared->m_redirect.is_valid()) {
+        *location = m_shared->m_redirect;
         *http_status_code = 303;
         return true;
     }
     return false;
 }
 
-void URLRequestCustomJob::setReplyMimeType(const std::string &mimeType)
+bool URLRequestCustomJob::ReadRawData(IOBuffer *buf, int bufSize, int *bytesRead)
+{
+    DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+    Q_ASSERT(bytesRead);
+    Q_ASSERT(m_shared);
+    QMutexLocker lock(&m_shared->m_mutex);
+    qint64 rv = m_shared->m_device ? m_shared->m_device->read(buf->data(), bufSize) : -1;
+    if (rv >= 0) {
+        *bytesRead = static_cast<int>(rv);
+        return true;
+    } else {
+        NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, ERR_FAILED));
+    }
+    return false;
+}
+
+URLRequestCustomJobShared::URLRequestCustomJobShared(URLRequestCustomJob *job)
+    : m_mutex(QMutex::Recursive)
+    , m_job(job)
+    , m_delegate(0)
+    , m_error(0)
+    , m_started(false)
+    , m_asyncInitialized(false)
+    , m_weakFactory(this)
+{
+}
+
+URLRequestCustomJobShared::~URLRequestCustomJobShared()
+{
+    Q_ASSERT(!m_job);
+    Q_ASSERT(!m_delegate);
+}
+
+void URLRequestCustomJobShared::killJob()
+{
+    DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+    QMutexLocker lock(&m_mutex);
+    m_job = 0;
+    bool doDelete = false;
+    if (m_delegate) {
+        m_delegate->deleteLater();
+    } else {
+        // Do not delete yet if startAsync has not yet run.
+        doDelete = m_asyncInitialized;
+    }
+    if (m_device && m_device->isOpen())
+        m_device->close();
+    m_device = 0;
+    m_weakFactory.InvalidateWeakPtrs();
+    lock.unlock();
+    if (doDelete)
+        delete this;
+}
+
+void URLRequestCustomJobShared::unsetJobDelegate()
+{
+    DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+    QMutexLocker lock(&m_mutex);
+    m_delegate = 0;
+    bool doDelete = false;
+    if (m_job)
+        abort();
+    else
+        doDelete = true;
+    lock.unlock();
+    if (doDelete)
+        delete this;
+}
+
+void URLRequestCustomJobShared::setReplyMimeType(const std::string &mimeType)
 {
     DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+    QMutexLocker lock(&m_mutex);
     m_mimeType = mimeType;
 }
 
-void URLRequestCustomJob::setReplyCharset(const std::string &charset)
+void URLRequestCustomJobShared::setReplyCharset(const std::string &charset)
 {
     DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+    QMutexLocker lock(&m_mutex);
     m_charset = charset;
 }
 
-void URLRequestCustomJob::setReplyDevice(QIODevice *device)
+void URLRequestCustomJobShared::setReplyDevice(QIODevice *device)
 {
     DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
     QMutexLocker lock(&m_mutex);
+    if (!m_job)
+        return;
     m_device = device;
     if (m_device && !m_device->isReadable())
         m_device->open(QIODevice::ReadOnly);
 
     if (m_device && m_device->isReadable())
-        content::BrowserThread::PostTask(content::BrowserThread::IO, FROM_HERE, base::Bind(&URLRequestCustomJob::notifyStarted, m_weakFactoryUI.GetWeakPtr()));
+        content::BrowserThread::PostTask(content::BrowserThread::IO, FROM_HERE, base::Bind(&URLRequestCustomJobShared::notifyStarted, m_weakFactory.GetWeakPtr()));
     else
         fail(ERR_INVALID_URL);
 }
 
-bool URLRequestCustomJob::ReadRawData(IOBuffer *buf, int bufSize, int *bytesRead)
-{
-    DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
-    Q_ASSERT(bytesRead);
-    QMutexLocker lock(&m_mutex);
-    qint64 rv = m_device ? m_device->read(buf->data(), bufSize) : -1;
-    if (rv >= 0) {
-        *bytesRead = static_cast<int>(rv);
-        return true;
-    } else {
-        NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, ERR_FAILED));
-    }
-    return false;
-}
-
-void URLRequestCustomJob::redirect(const GURL &url)
+void URLRequestCustomJobShared::redirect(const GURL &url)
 {
     DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-    if (m_device || m_error)
-        return;
 
     QMutexLocker lock(&m_mutex);
+    if (m_device || m_error)
+        return;
+    if (!m_job)
+        return;
     m_redirect = url;
-    content::BrowserThread::PostTask(content::BrowserThread::IO, FROM_HERE, base::Bind(&URLRequestCustomJob::notifyStarted, m_weakFactoryUI.GetWeakPtr()));
+    content::BrowserThread::PostTask(content::BrowserThread::IO, FROM_HERE, base::Bind(&URLRequestCustomJobShared::notifyStarted, m_weakFactory.GetWeakPtr()));
 }
 
-void URLRequestCustomJob::abort()
+void URLRequestCustomJobShared::abort()
 {
     DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
     QMutexLocker lock(&m_mutex);
     if (m_device && m_device->isOpen())
         m_device->close();
     m_device = 0;
-    content::BrowserThread::PostTask(content::BrowserThread::IO, FROM_HERE, base::Bind(&URLRequestCustomJob::notifyCanceled, m_weakFactoryUI.GetWeakPtr()));
+    if (!m_job)
+        return;
+    content::BrowserThread::PostTask(content::BrowserThread::IO, FROM_HERE, base::Bind(&URLRequestCustomJobShared::notifyCanceled, m_weakFactory.GetWeakPtr()));
 }
 
-void URLRequestCustomJob::notifyCanceled()
+void URLRequestCustomJobShared::notifyCanceled()
 {
     DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+    QMutexLocker lock(&m_mutex);
+    if (!m_job)
+        return;
     if (m_started)
-        NotifyDone(URLRequestStatus(URLRequestStatus::CANCELED, ERR_ABORTED));
+        m_job->NotifyDone(URLRequestStatus(URLRequestStatus::CANCELED, ERR_ABORTED));
     else
-        NotifyStartError(URLRequestStatus(URLRequestStatus::CANCELED, ERR_ABORTED));
+        m_job->NotifyStartError(URLRequestStatus(URLRequestStatus::CANCELED, ERR_ABORTED));
 }
 
-void URLRequestCustomJob::notifyStarted()
+void URLRequestCustomJobShared::notifyStarted()
 {
     DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+    QMutexLocker lock(&m_mutex);
+    if (!m_job)
+        return;
     Q_ASSERT(!m_started);
     m_started = true;
-    NotifyHeadersComplete();
+    m_job->NotifyHeadersComplete();
 }
 
-void URLRequestCustomJob::fail(int error)
+void URLRequestCustomJobShared::fail(int error)
 {
     DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
     QMutexLocker lock(&m_mutex);
     m_error = error;
-    content::BrowserThread::PostTask(content::BrowserThread::IO, FROM_HERE, base::Bind(&URLRequestCustomJob::notifyFailure, m_weakFactoryUI.GetWeakPtr()));
+    if (!m_job)
+        return;
+    content::BrowserThread::PostTask(content::BrowserThread::IO, FROM_HERE, base::Bind(&URLRequestCustomJobShared::notifyFailure, m_weakFactory.GetWeakPtr()));
 }
 
-void URLRequestCustomJob::notifyFailure()
+void URLRequestCustomJobShared::notifyFailure()
 {
     DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
     QMutexLocker lock(&m_mutex);
+    if (!m_job)
+        return;
     if (m_device)
         m_device->close();
-    if (m_started)
-        NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, m_error));
+    const URLRequestStatus status(URLRequestStatus::FAILED, m_error);
+    const bool started = m_started;
+
+    if (started)
+        m_job->NotifyDone(status);
     else
-        NotifyStartError(URLRequestStatus(URLRequestStatus::FAILED, m_error));
+        m_job->NotifyStartError(status);
 }
 
-void URLRequestCustomJob::startAsync()
+GURL URLRequestCustomJobShared::requestUrl()
+{
+    QMutexLocker lock(&m_mutex);
+    if (!m_job)
+        return GURL();
+    return m_job->request()->url();
+}
+
+std::string URLRequestCustomJobShared::requestMethod()
+{
+    QMutexLocker lock(&m_mutex);
+    if (!m_job)
+        return std::string();
+    return m_job->request()->method();
+}
+
+void URLRequestCustomJobShared::startAsync()
 {
     DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
     Q_ASSERT(!m_started);
     Q_ASSERT(!m_delegate);
     QMutexLocker lock(&m_mutex);
+    if (!m_job) {
+        lock.unlock();
+        delete this;
+        return;
+    }
     m_delegate = new URLRequestCustomJobDelegate(this);
-    lock.unlock();
+    m_asyncInitialized = true;
     QWebEngineUrlRequestJob *requestJob = new QWebEngineUrlRequestJob(m_delegate);
-    m_schemeHandler->requestStarted(requestJob);
+    if (m_job)
+        m_job->m_schemeHandler->requestStarted(requestJob);
 }
 
 } // namespace