--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/webengine/osswebengine/WebCore/platform/network/symbian/SynchLoader.cpp	Mon Mar 30 12:54:55 2009 +0300
@@ -0,0 +1,238 @@
+/*
+* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of the License "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:  Implementation of SynchResourceHandleClient
+*
+*/
+
+
+// INCLUDE FILES
+
+#include "config.h"
+
+#include "SynchLoader.h"
+
+#include "DocumentLoader.h"
+#include "FrameLoader.h"
+
+namespace WebCore {
+
+// ============================SynchLoader MEMBER FUNCTIONS ===============================
+
+class SynchResourceHandleClient;
+
+SynchLoader::SynchLoader(Frame* frame, SynchResourceHandleClient* client, bool sendResourceLoadCallbacks, bool shouldContentSniff)
+    : ResourceLoader(frame, sendResourceLoadCallbacks, shouldContentSniff)
+    , m_client(client)
+    , m_isdone(false)
+{
+    m_documentLoader->addSubresourceLoader(this);
+}
+
+SynchLoader::~SynchLoader()
+{    
+}
+
+PassRefPtr<SynchLoader> SynchLoader::create(Frame* frame, const ResourceRequest& request, SynchResourceHandleClient* client)
+{
+    if (!frame)
+        return 0;
+    
+    FrameLoader* fl = frame->loader();
+    if (fl->state() == FrameStateProvisional)
+        return 0;
+    
+    RefPtr<SynchLoader> loader(new SynchLoader(frame, client, true, false));
+    if (!loader->load(request)) {
+        return 0;
+    }
+
+    return loader.release();
+}
+
+bool SynchLoader::load(const ResourceRequest& r)
+{
+    return ResourceLoader::load(r);
+}
+
+void SynchLoader::didReceiveResponse(const ResourceResponse& r)
+{
+    ASSERT(!r.isNull());
+
+    if (m_client) {
+        m_client->didReceiveResponse(m_client->resourceHandle(), r);
+    }
+}
+
+void SynchLoader::didReceiveData(const char* data, int length, long long lengthReceived, bool allAtOnce)
+{
+    if (m_client) {
+        m_client->didReceiveData(m_client->resourceHandle(), data, length, lengthReceived);
+    }
+}
+
+void SynchLoader::didFinishLoading()
+{
+    if (cancelled()) {
+        return;
+    }
+
+    // Decrement ref counter on handle, so connection can be torn down or cancelled
+    m_handle = 0;
+
+    if (m_client) {
+        m_client->didFinishLoading(m_client->resourceHandle());
+    }
+}
+
+void SynchLoader::didFail(const ResourceError& error)
+{
+    if (cancelled()) {
+        return;
+    }
+
+    // Decrement ref counter on handle, so connection can be torn down or cancelled
+    m_handle = 0;
+
+    if (m_client) {
+        m_client->didFail(m_client->resourceHandle(), error);
+    }
+}
+
+void SynchLoader::didCancel(const ResourceError& /*error*/)
+{
+    // Decrement ref counter on handle, so connection can be cancelled
+    m_handle = 0;
+
+    if (m_client) {
+        m_client->cancel();    
+    }
+}
+
+void SynchLoader::removeSubresourceLoader()
+{
+    if (!m_isdone) {
+        // Avoid multiple cycles
+        m_isdone = true;
+        
+        RefPtr<SynchLoader> protect(this);
+        
+        m_documentLoader->removeSubresourceLoader(this);
+    }
+ 
+}
+
+
+// ============================ SynchResourceHandleClient MEMBER FUNCTIONS ===============================
+
+SynchResourceHandleClient::SynchResourceHandleClient(TRequestStatus& aStatus, 
+                                                     const ResourceRequest& request, 
+                                                     Frame* frame)
+    : m_finished(false)
+    , m_response()
+    , m_error(String(), KErrNone, String(), String())
+    , m_data(0)
+{
+    m_status = &aStatus;
+    
+    // Send request
+    m_loader = SynchLoader::create(frame, request, this);
+    
+    if (m_loader) {
+        m_resourceHandle = m_loader->handle();
+    }
+}
+
+SynchResourceHandleClient::~SynchResourceHandleClient()
+{
+}
+
+PassRefPtr<SynchResourceHandleClient> SynchResourceHandleClient::create(TRequestStatus& aStatus, 
+                                                                        const ResourceRequest& request, 
+                                                                        Frame* frame)
+{
+    RefPtr<SynchResourceHandleClient> client(new SynchResourceHandleClient(aStatus, request, frame));
+    if (!client->loader()) {
+        return 0;
+    }
+
+    return client.release();
+}
+
+void SynchResourceHandleClient::didReceiveResponse(ResourceHandle* /*resource*/, const ResourceResponse& response)
+{
+    m_response = response;
+}
+
+void SynchResourceHandleClient::didReceiveData(ResourceHandle* /*resource*/, const char* data, int length, int /*lengthReceived*/)
+{
+    m_data.append(data, length);
+}
+
+void SynchResourceHandleClient::didFinishLoading(ResourceHandle* /*resource*/)
+{
+    // Decrement ref counter on handle, so connection can be torn down or cancelled
+    m_resourceHandle = 0;
+    
+    finish(ResourceError());
+}
+
+void SynchResourceHandleClient::didFail(ResourceHandle* /*resource*/, const ResourceError& error)
+{
+    // Decrement ref counter on handle, so connection can be torn down or cancelled
+    m_resourceHandle = 0;
+    
+    finish(error);
+}
+
+void SynchResourceHandleClient::cancel()
+{
+    cancel(ResourceError(String(), KErrCancel, String(), String()));
+}
+
+void SynchResourceHandleClient::cancel(const ResourceError& err)
+{
+    // Operation was cancelled
+    // Need to cancel outstanding request, if not done so already
+    if (resourceHandle()) {
+        ResourceHandle* h = m_resourceHandle.get();
+        m_resourceHandle = 0;
+        h->cancel();
+    }
+    
+    finish(err);
+}
+
+void SynchResourceHandleClient::finish(const ResourceError& error)
+{
+    m_error = error;
+    
+    if (!m_finished) { // Avoid multiple execution
+        if (m_loader) {
+            m_loader->removeSubresourceLoader();
+        }
+
+        if (m_status) {       
+            // Complete SynchRequest AO
+            if (KRequestPending == m_status->Int()) {
+                User::RequestComplete(m_status, error.errorCode());
+            }        
+        }
+    }
+    
+    m_finished = true;
+    //m_loader = 0;
+}
+
+} // End namespace WebCore
+