Correct data size argument type in resource loading path to unsigned

Source/core/xml/XMLHttpRequest.cpp

 /*
  *  Copyright (C) 2004, 2006, 2008 Apple Inc. All rights reserved.
  *  Copyright (C) 2005-2007 Alexey Proskuryakov <ap@webkit.org>
  *  Copyright (C) 2007, 2008 Julien Chaffraix <jchaffraix@webkit.org>
  *  Copyright (C) 2008, 2011 Google Inc. All rights reserved.
  *  Copyright (C) 2012 Intel Corporation
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Lesser General Public
  *  License as published by the Free Software Foundation; either
@@ skipping 424 matching lines @@
     return m_response.url().string();
 }
 
 XMLHttpRequestUpload* XMLHttpRequest::upload()
 {
     if (!m_upload)
         m_upload = XMLHttpRequestUpload::create(this);
     return m_upload.get();
 }
 
-void XMLHttpRequest::trackProgress(int length)
+void XMLHttpRequest::trackProgress(long long length)

[tkent, 2014/10/01 03:16:49]

Why |long long|?

[tyoshino (SeeGerritForStatus), 2014/10/01 03:36:09]

The argument of didDownloadData() is still "int". This should also be fixed but
in another CL. Until that, I'd like to replace this with a type with larger
range not to care about overflow on trackProgress() call in didReceiveData()
while making no change on the path from didDownloadData() to trackProgress()
where int is passed to trackProgress().

 {
     m_receivedLength += length;
 
     if (m_state != LOADING) {
         changeState(LOADING);
     } else {
         // Dispatch a readystatechange event because many applications use
         // it to track progress although this is not specified.
         //
         // FIXME: Stop dispatching this event for progress tracking.
@@ skipping 929 matching lines @@
     m_response = response;
     if (!m_mimeTypeOverride.isEmpty()) {
         m_response.setHTTPHeaderField("Content-Type", m_mimeTypeOverride);
         m_finalResponseCharset = extractCharsetFromMediaType(m_mimeTypeOverride);
     }
 
     if (m_finalResponseCharset.isEmpty())
         m_finalResponseCharset = response.textEncodingName();
 }
 
-void XMLHttpRequest::parseDocumentChunk(const char* data, int len)
+void XMLHttpRequest::parseDocumentChunk(const char* data, unsigned len)
 {
     if (!m_responseDocumentParser) {
         ASSERT(!m_responseDocument);
         initResponseDocument();
         if (!m_responseDocument)
             return;
 
         m_responseDocumentParser = m_responseDocument->implicitOpen();
         m_responseDocumentParser->addClient(this);
     }
@@ skipping 23 matching lines @@
 
         return decoder.release();
     }
 
     if (responseIsHTML())
         return TextResourceDecoder::create("text/html", "UTF-8");
 
     return TextResourceDecoder::create("text/plain", "UTF-8");
 }
 
-void XMLHttpRequest::didReceiveData(const char* data, int len)
+void XMLHttpRequest::didReceiveData(const char* data, unsigned len)
 {
     ASSERT(!m_downloadingToFile);
 
     if (m_error)
         return;
 
     if (m_state < HEADERS_RECEIVED)
         changeState(HEADERS_RECEIVED);
 
     // We need to check for |m_error| again, because |changeState| may trigger
     // readystatechange, and user javascript can cause |abort()|.
     if (m_error)
         return;
 
     if (!len)
         return;
 
-    if (len == -1)
-        len = strlen(data);
-
     if (m_responseTypeCode == ResponseTypeDocument && responseIsHTML()) {
         parseDocumentChunk(data, len);
     } else if (m_responseTypeCode == ResponseTypeDefault || m_responseTypeCode == ResponseTypeText || m_responseTypeCode == ResponseTypeJSON || m_responseTypeCode == ResponseTypeDocument) {
         if (!m_decoder)
             m_decoder = createDecoder();
 
         m_responseText = m_responseText.concatenateWith(m_decoder->decode(data, len));
     } else if (m_responseTypeCode == ResponseTypeArrayBuffer || m_responseTypeCode == ResponseTypeBlob) {
         // Buffer binary data.
         if (!m_binaryResponseBuilder)
@@ skipping 100 matching lines @@
     visitor->trace(m_responseStream);
     visitor->trace(m_streamSource);
     visitor->trace(m_responseDocument);
     visitor->trace(m_responseDocumentParser);
     visitor->trace(m_progressEventThrottle);
     visitor->trace(m_upload);
     XMLHttpRequestEventTarget::trace(visitor);
 }
 
 } // namespace blink