MCL/sf/mw/web: comparison webengine/osswebengine/WebCore/platform/network/symbian/HttpConnection.cpp

equal deleted inserted replaced

-:79859ed3eea9
+:919f36ff910f
 *
 * Description:
 *
 */
-#include <uri8.h>
+#include <Uri8.h>
-#include <escapeutils.h>
+#include <EscapeUtils.h>
 #include <http/rhttpheaders.h>
 #include <http/mhttpdatasupplier.h>
 #include <thttpfields.h>
 #include "ResourceHandle.h"
 #include "ResourceHandleInternal.h"
 #include "StaticObjectsContainer.h"
 #include "ResourceLoaderDelegate.h"
 #include "HttpCacheSupply.h"
 #include "HttpPostDataSupplier.h"
 #include <httpfiltercommonstringsext.h>
-#include <BrCtlDefs.h>
+#include <brctldefs.h>
 #include "BrCtl.h"
-#include "BrCtlSpecialLoadObserver.h"
+#include <brctlspecialloadobserver.h>
 #include "Frame.h"
 #include "FrameLoader.h"
 #include "DocumentLoader.h"
 #include "HttpUiCallbacks.h"
 #include "HttpRequestHeaderManager.h"
 return KErrNone;
 }
 void DefersData::Activate()
 {
-SetActive();
+if(!IsActive())
-iStatus = KRequestPending;
+{
-TRequestStatus* status = &iStatus;
+SetActive();
-User::RequestComplete( status, KErrNone );
+iStatus = KRequestPending;
+TRequestStatus* status = &iStatus;
+User::RequestComplete( status, KErrNone );
+}
 }
 ReceivedFinished::ReceivedFinished(void* ctx, ReceivedFinishedCallback callback) : CActive(CActive::EPriorityStandard)
 {
 delete m_defersData;
 delete m_receivedFinished;
 delete m_unknownContentHandler;
 delete m_cacheSupply;
 delete m_postDataSupplier;
+if(m_transaction)
+m_transaction->Close();
 delete m_transaction;
 }
 HttpConnection* HttpConnection::connectionFromTransaction(RHTTPTransaction& transaction)
 {
 }
 void HttpConnection::submitL()
 {
 __ASSERT_DEBUG( !m_transaction, THttpConnUtils::PanicLoader( KErrArgument ) );
+TBool retryFlag = StaticObjectsContainer::instance()->resourceLoaderDelegate()->httpSessionManager()->getRetryConnectivityFlag();
+if( retryFlag )
+return;
 HttpSessionManager* httpSessionMgr = StaticObjectsContainer::instance()->resourceLoaderDelegate()->httpSessionManager();
 User::LeaveIfNull(httpSessionMgr);
 httpSessionMgr->openHttpSessionIfNeededL();
 TPtrC8 urlPtr( m_handle->request().url().des() );
 {
 //
 complete( authRet );
 return;
 }
+}
+if(httpStatus == EHttpNotAcceptable)
+{
+complete(KBrowserHTTPStatusCodes - m_transaction->Response().StatusCode());
+return;
 }
 if ( !handled )
 {
 // url
 m_urlResponse = NULL;
 if (!m_transaction) {
 // this object might be invalid at this point.
 return;
 }
 int statusCode = m_transaction->Response().StatusCode();
-if ( statusCode != 200) {
+if ((statusCode == 404) && (aEvent.iStatus == THTTPEvent::EFailed) && (m_accumulatedSize != 0)) {
+complete(KErrNone);
+}
+else if ( statusCode != 200) {
 complete(-25000 - m_transaction->Response().StatusCode());
 }
 else if (statusCode == 200 && aEvent.iStatus == THTTPEvent::EFailed) {
 // this is a weird combination, it is caused by cached supplier when a response only has the
 // response header, but no response body is sent by the HTTP stack.  It is a legitimate senario though.
 TPtrC8 uriNoFrag;
 // extract non-fragment portion into uriNoFrag
 uriParser.UriWithoutFragment( uriNoFrag );
 TUriParser8 parserNoFrag;
 parserNoFrag.Parse( uriNoFrag );
-m_transaction->Request().SetURIL( parserNoFrag );
 // now save the fragment for later use
 const TDesC8& fragment = uriParser.Extract( EUriFragment );
 delete m_frag;
 m_frag = NULL;
-m_frag = fragment.AllocL();
+//Browser does not allow fragment size of greater than 2083 bytes
+TInt32 maxbyte = fragment.Length();
+if ( maxbyte <= 2083)
+{
+m_frag = fragment.AllocL();
+}
+m_transaction->Request().SetURIL( parserNoFrag );
 }
 HandleSpecialEvent(aEvent.iStatus);
 break;
 }
 case THTTPEvent::EGotResponseTrailerHeaders:
 break;// We don't process this event
 }
 default:
 {
 // error handling
-handleError(aEvent.iStatus);
+//KErrDisconnected should be coming only for OCC
+//MHFRunL gets call before connection manager
+if(aEvent.iStatus == KErrNotReady)
+{
+StaticObjectsContainer::instance()->resourceLoaderDelegate()->httpSessionManager()->setRetryConnectivityFlag();
+StaticObjectsContainer::instance()->resourceLoaderDelegate()->httpSessionManager()->startTimer();
+}
+else
+handleError(aEvent.iStatus);
 break;
 }
 }
 }
 return ret;
 }
 void HttpConnection::complete(int error)
 {
+HttpSessionManager* httpSessionManager = StaticObjectsContainer::instance()->resourceLoaderDelegate()->httpSessionManager();
+TBool retryFlag = httpSessionManager->getRetryConnectivityFlag();
+if( retryFlag )
+{
+return;
+}
 if (m_defersData) {
 m_defersData->m_done = true;
 m_defersData->m_error = error;
 return;
 }
 CResourceHandleManager::self()->receivedResponse(m_handle, response, this);
 CResourceHandleManager::self()->receivedData(m_handle,
 m_MultipartContentHandler->MarkupContent(), m_maxSize, this);
 }
 delete m_MultipartContentHandler;
+m_IsMultipart = false;
 }
 if (!error) {
 // Spawn active object for call to return immediately, to avoid blocking
 activateReceivedFinished(error);
 }
 if (m_transaction) {
 m_transaction->Cancel();
 m_transaction->Close();
 delete m_transaction;
 m_transaction = NULL;
+httpSessionManager->removeRequest(this);
 }
 if (error) {
 CResourceHandleManager::self()->receivedFinished(m_handle, error, this);
 derefHandle();
 }
 {
 __ASSERT_DEBUG( EFalse, THttpConnUtils::PanicLoader( KErrArgument ) );
 break;
 }
 }
+m_isDone = ETrue;
 TRAP( ret, SendAuthRequestL( usernameVal, realmVal, isProxy, stale, passwordVal ) );
 if (realmClose)
 {
 realmVal.Str().Close();
 }
 // Execution is back from the dialog, move the transaction
 // from the authentication listback into active list
 HttpSessionManager* httpSessionMgr = StaticObjectsContainer::instance()->resourceLoaderDelegate()->httpSessionManager();
 httpSessionMgr->removeAuthRequest(this);
 httpSessionMgr->addRequest(this, m_handle);
+m_isDone = EFalse;
 switch (aError)
 {
 case KErrNone:
 {
 TRAP( ret, this->AddAuthenticationPropertiesL( aUsername, aPassword, aProxy) );
 }
 }
 //When submitting the request iSecurePage was set based on the request url
 //Check the redirect url and see if the scheme has changed
 HttpSessionManager* httpSessionMgr = StaticObjectsContainer::instance()->resourceLoaderDelegate()->httpSessionManager();
-if(requestedSecScheme && !redirectedSecScheme) //redirection from a secure page to an unsecure one
+if(httpSessionMgr->isInSecureConnection() && requestedSecScheme && !redirectedSecScheme) //redirection from a secure page to an unsecure one
 {
 error = httpSessionMgr->uiCallback()->aboutToLoadPage(control(m_frame), HttpUiCallbacks::EExitingSecurePage);
-}
+httpSessionMgr->setInSecureConnection(EFalse);
-else if(redirectedSecScheme && !requestedSecScheme) //redirection to unsecurepage when secure page was requested
+}
+else if(!httpSessionMgr->isInSecureConnection() && redirectedSecScheme && !requestedSecScheme) //redirection to unsecurepage when secure page was requested
 {
 error = httpSessionMgr->uiCallback()->aboutToLoadPage(control(m_frame), HttpUiCallbacks::EEnteringSecurePage );
-}
+httpSessionMgr->setInSecureConnection(ETrue);
 }
+}
 return error;
 }
 // -----------------------------------------------------------------------------
 // HttpConnection::CheckForNonHttpRedirect
 __ASSERT_DEBUG( m_transaction, THttpConnUtils::PanicLoader( KErrArgument ) );
 if(uriParser.Parse( m_transaction->Request().URI().UriDes() ) == KErrNone)
 {
-if (uriParser.IsPresent(EUriHost) && uriParser.IsPresent(EUriScheme)) // looking only for absolue Url path and schemes other than http(s)
+if (uriParser.IsPresent(EUriScheme)) // looking only for absolue Url path and schemes other than http(s)
 {
 const TDesC8& scheme = uriParser.Extract(EUriScheme);
-if (scheme.FindF(_L8("http")) == KErrNotFound) // everything but http(s)
+if(uriParser.IsPresent(EUriHost) || scheme.FindF(_L8("tel")) == KErrNone)
 {
-TPtrC8 ptr(uriParser.UriDes());
+if (scheme.FindF(_L8("http")) == KErrNotFound) // everything but http(s)
-// these arrays are pushed into CleanupStack in case leave
-// if no leave, they will be freed below
-RArray<TUint>* typeArray = new (ELeave) RArray<TUint>(1);
-CleanupStack::PushL(typeArray);
-CDesCArrayFlat* desArray = new (ELeave) CDesCArrayFlat(1);
-CleanupStack::PushL(desArray);
-User::LeaveIfError(typeArray->Append(EParamRequestUrl));
-HBufC16* urlbuf = HBufC16::NewLC( ptr.Length()  + 1); // +1 for zero terminate
-urlbuf->Des().Copy( ptr );
-TPtr16 bufDes16 = urlbuf->Des();
-bufDes16.ZeroTerminate();
-desArray->AppendL(bufDes16);
-CleanupStack::Pop();
-MBrCtlSpecialLoadObserver* loadObserver = control(m_frame)->brCtlSpecialLoadObserver();
-if (loadObserver)
 {
-TRAP_IGNORE(loadObserver->HandleRequestL(typeArray, desArray));
+TPtrC8 ptr(uriParser.UriDes());
-}
+// these arrays are pushed into CleanupStack in case leave
+// if no leave, they will be freed below
-// No leave, so pop here and clean up
+RArray<TUint>* typeArray = new (ELeave) RArray<TUint>(1);
-CleanupStack::Pop(desArray);
+CleanupStack::PushL(typeArray);
-CleanupStack::Pop(typeArray);
+CDesCArrayFlat* desArray = new (ELeave) CDesCArrayFlat(1);
-// cleanup arrays
+CleanupStack::PushL(desArray);
-if (typeArray)
-{
+User::LeaveIfError(typeArray->Append(EParamRequestUrl));
-// Closes the array and frees all memory allocated to the array
-typeArray->Close();
+HBufC16* urlbuf = HBufC16::NewLC( ptr.Length()  + 1); // +1 for zero terminate
-delete typeArray;
+urlbuf->Des().Copy( ptr );
-}
+TPtr16 bufDes16 = urlbuf->Des();
+bufDes16.ZeroTerminate();
-if (desArray)
-{
+desArray->AppendL(bufDes16);
-// Deletes all descriptors from the array and frees the memory allocated to the array buffer
+CleanupStack::Pop();
-desArray->Reset();
-delete desArray;
+MBrCtlSpecialLoadObserver* loadObserver = control(m_frame)->brCtlSpecialLoadObserver();
-}
+if (loadObserver)
-return KErrCancel;
+{
+TRAP_IGNORE(loadObserver->HandleRequestL(typeArray, desArray));
+}
+// No leave, so pop here and clean up
+CleanupStack::Pop(desArray);
+CleanupStack::Pop(typeArray);
+// cleanup arrays
+if (typeArray)
+{
+// Closes the array and frees all memory allocated to the array
+typeArray->Close();
+delete typeArray;
+}
+if (desArray)
+{
+// Deletes all descriptors from the array and frees the memory allocated to the array buffer
+desArray->Reset();
+delete desArray;
+}
+return KErrCancel;
+}
 }
 }
 }
 return KErrNone;
 }
 RHTTPTransaction* trans = m_transaction;
 RHTTPSession& session = StaticObjectsContainer::instance()->resourceLoaderDelegate()->httpSessionManager()->httpSession();
 // remove own address from transaction properties
 m_transaction->PropertySet().RemoveProperty(session.StringPool().StringF(HttpFilterCommonStringsExt::ESelfPtr,
 HttpFilterCommonStringsExt::GetTable()));
+if(m_cacheSupply->IsSupplying())
+{
+//Download is started from cache.
+m_cacheSupply->SetDownloadTransaction(m_transaction);
+}
 m_transaction = NULL;
+m_isDone = true;
 return trans;
 }
 // -----------------------------------------------------------------------------
 // HttpConnection::addIMEINotifyPropertiesL

branch	RCL_3
changeset 49	919f36ff910f
parent 48	79859ed3eea9
child 50	d96eed154187