src/declarative/qml/qdeclarativexmlhttprequest.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
   4 ** All rights reserved.
   5 ** Contact: Nokia Corporation (qt-info@nokia.com)
   6 **
   7 ** This file is part of the QtDeclarative module of the Qt Toolkit.
   8 **
   9 ** $QT_BEGIN_LICENSE:LGPL$
  10 ** GNU Lesser General Public License Usage
  11 ** This file may be used under the terms of the GNU Lesser General Public
  12 ** License version 2.1 as published by the Free Software Foundation and
  13 ** appearing in the file LICENSE.LGPL included in the packaging of this
  14 ** file. Please review the following information to ensure the GNU Lesser
  15 ** General Public License version 2.1 requirements will be met:
  16 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  17 **
  18 ** In addition, as a special exception, Nokia gives you certain additional
  19 ** rights. These rights are described in the Nokia Qt LGPL Exception
  20 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  21 **
  22 ** GNU General Public License Usage
  23 ** Alternatively, this file may be used under the terms of the GNU General
  24 ** Public License version 3.0 as published by the Free Software Foundation
  25 ** and appearing in the file LICENSE.GPL included in the packaging of this
  26 ** file. Please review the following information to ensure the GNU General
  27 ** Public License version 3.0 requirements will be met:
  28 ** http://www.gnu.org/copyleft/gpl.html.
  29 **
  30 ** Other Usage
  31 ** Alternatively, this file may be used in accordance with the terms and
  32 ** conditions contained in a signed written agreement between you and Nokia.
  33 **
  34 **
  35 **
  36 **
  37 **
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41
  42 #include "private/qdeclarativexmlhttprequest_p.h"
  43
  44 #include <private/qv8engine_p.h>
  45
  46 #include "qdeclarativeengine.h"
  47 #include "private/qdeclarativeengine_p.h"
  48 #include "private/qdeclarativerefcount_p.h"
  49 #include "private/qdeclarativeengine_p.h"
  50 #include "private/qdeclarativeexpression_p.h"
  51 #include "qdeclarativeglobal_p.h"
  52
  53 #include <QtCore/qobject.h>
  54 #include <QtDeclarative/qjsvalue.h>
  55 #include <QtDeclarative/qjsengine.h>
  56 #include <QtNetwork/qnetworkreply.h>
  57 #include <QtCore/qtextcodec.h>
  58 #include <QtCore/qxmlstream.h>
  59 #include <QtCore/qstack.h>
  60 #include <QtCore/qdebug.h>
  61
  62 #include <QtCore/QStringBuilder>
  63
  64 #ifndef QT_NO_XMLSTREAMREADER
  65
  66 // From DOM-Level-3-Core spec
  67 // http://www.w3.org/TR/DOM-Level-3-Core/core.html
  68 #define INDEX_SIZE_ERR 1
  69 #define DOMSTRING_SIZE_ERR 2
  70 #define HIERARCHY_REQUEST_ERR 3
  71 #define WRONG_DOCUMENT_ERR 4
  72 #define INVALID_CHARACTER_ERR 5
  73 #define NO_DATA_ALLOWED_ERR 6
  74 #define NO_MODIFICATION_ALLOWED_ERR 7
  75 #define NOT_FOUND_ERR 8
  76 #define NOT_SUPPORTED_ERR 9
  77 #define INUSE_ATTRIBUTE_ERR 10
  78 #define INVALID_STATE_ERR 11
  79 #define SYNTAX_ERR 12
  80 #define INVALID_MODIFICATION_ERR 13
  81 #define NAMESPACE_ERR 14
  82 #define INVALID_ACCESS_ERR 15
  83 #define VALIDATION_ERR 16
  84 #define TYPE_MISMATCH_ERR 17
  85
  86 #define V8THROW_DOM(error, string) { \
  87     v8::Local<v8::Value> v = v8::Exception::Error(v8::String::New(string)); \
  88     v->ToObject()->Set(v8::String::New("code"), v8::Integer::New(error)); \
  89     v8::ThrowException(v); \
  90     return v8::Handle<v8::Value>(); \
  91 }
  92
  93 #define V8THROW_REFERENCE(string) { \
  94     v8::ThrowException(v8::Exception::ReferenceError(v8::String::New(string))); \
  95     return v8::Handle<v8::Value>(); \
  96 }
  97
  98 #define D(arg) (arg)->release()
  99 #define A(arg) (arg)->addref()
 100
 101 QT_BEGIN_NAMESPACE
 102
 103 DEFINE_BOOL_CONFIG_OPTION(xhrDump, QML_XHR_DUMP);
 104
 105 struct QDeclarativeXMLHttpRequestData {
 106     QDeclarativeXMLHttpRequestData();
 107     ~QDeclarativeXMLHttpRequestData();
 108
 109     v8::Persistent<v8::Function> nodeFunction;
 110
 111     v8::Persistent<v8::Object> namedNodeMapPrototype;
 112     v8::Persistent<v8::Object> nodeListPrototype;
 113     v8::Persistent<v8::Object> nodePrototype;
 114     v8::Persistent<v8::Object> elementPrototype;
 115     v8::Persistent<v8::Object> attrPrototype;
 116     v8::Persistent<v8::Object> characterDataPrototype;
 117     v8::Persistent<v8::Object> textPrototype;
 118     v8::Persistent<v8::Object> cdataPrototype;
 119     v8::Persistent<v8::Object> documentPrototype;
 120
 121     v8::Local<v8::Object> newNode();
 122 };
 123
 124 static inline QDeclarativeXMLHttpRequestData *xhrdata(QV8Engine *engine)
 125 {
 126     return (QDeclarativeXMLHttpRequestData *)engine->xmlHttpRequestData();
 127 }
 128
 129 QDeclarativeXMLHttpRequestData::QDeclarativeXMLHttpRequestData()
 130 {
 131 }
 132
 133 QDeclarativeXMLHttpRequestData::~QDeclarativeXMLHttpRequestData()
 134 {
 135     qPersistentDispose(nodeFunction);
 136     qPersistentDispose(namedNodeMapPrototype);
 137     qPersistentDispose(nodeListPrototype);
 138     qPersistentDispose(nodePrototype);
 139     qPersistentDispose(elementPrototype);
 140     qPersistentDispose(attrPrototype);
 141     qPersistentDispose(characterDataPrototype);
 142     qPersistentDispose(textPrototype);
 143     qPersistentDispose(cdataPrototype);
 144     qPersistentDispose(documentPrototype);
 145 }
 146
 147 v8::Local<v8::Object> QDeclarativeXMLHttpRequestData::newNode()
 148 {
 149     if (nodeFunction.IsEmpty()) {
 150         v8::Local<v8::FunctionTemplate> ft = v8::FunctionTemplate::New();
 151         ft->InstanceTemplate()->SetHasExternalResource(true);
 152         nodeFunction = qPersistentNew<v8::Function>(ft->GetFunction());
 153     }
 154
 155     return nodeFunction->NewInstance();
 156 }
 157
 158 namespace {
 159
 160 class DocumentImpl;
 161 class NodeImpl
 162 {
 163 public:
 164     NodeImpl() : type(Element), document(0), parent(0) {}
 165     virtual ~NodeImpl() {
 166         for (int ii = 0; ii < children.count(); ++ii)
 167             delete children.at(ii);
 168         for (int ii = 0; ii < attributes.count(); ++ii)
 169             delete attributes.at(ii);
 170     }
 171
 172     // These numbers are copied from the Node IDL definition
 173     enum Type {
 174         Attr = 2,
 175         CDATA = 4,
 176         Comment = 8,
 177         Document = 9,
 178         DocumentFragment = 11,
 179         DocumentType = 10,
 180         Element = 1,
 181         Entity = 6,
 182         EntityReference = 5,
 183         Notation = 12,
 184         ProcessingInstruction = 7,
 185         Text = 3
 186     };
 187     Type type;
 188
 189     QString namespaceUri;
 190     QString name;
 191
 192     QString data;
 193
 194     void addref();
 195     void release();
 196
 197     DocumentImpl *document;
 198     NodeImpl *parent;
 199
 200     QList<NodeImpl *> children;
 201     QList<NodeImpl *> attributes;
 202 };
 203
 204 class DocumentImpl : public QDeclarativeRefCount, public NodeImpl
 205 {
 206 public:
 207     DocumentImpl() : root(0) { type = Document; }
 208     virtual ~DocumentImpl() {
 209         if (root) delete root;
 210     }
 211
 212     QString version;
 213     QString encoding;
 214     bool isStandalone;
 215
 216     NodeImpl *root;
 217
 218     void addref() { QDeclarativeRefCount::addref(); }
 219     void release() { QDeclarativeRefCount::release(); }
 220 };
 221
 222 class NamedNodeMap
 223 {
 224 public:
 225     // JS API
 226     static v8::Handle<v8::Value> length(v8::Local<v8::String>, const v8::AccessorInfo& args);
 227     static v8::Handle<v8::Value> indexed(uint32_t index, const v8::AccessorInfo& info);
 228     static v8::Handle<v8::Value> named(v8::Local<v8::String> property, const v8::AccessorInfo& args);
 229
 230     // C++ API
 231     static v8::Handle<v8::Object> prototype(QV8Engine *);
 232     static v8::Handle<v8::Value> create(QV8Engine *, NodeImpl *, QList<NodeImpl *> *);
 233 };
 234
 235 class NodeList
 236 {
 237 public:
 238     // JS API
 239     static v8::Handle<v8::Value> length(v8::Local<v8::String>, const v8::AccessorInfo& args);
 240     static v8::Handle<v8::Value> indexed(uint32_t index, const v8::AccessorInfo& info);
 241
 242     // C++ API
 243     static v8::Handle<v8::Object> prototype(QV8Engine *);
 244     static v8::Handle<v8::Value> create(QV8Engine *, NodeImpl *);
 245 };
 246
 247 class Node
 248 {
 249 public:
 250     // JS API
 251     static v8::Handle<v8::Value> nodeName(v8::Local<v8::String>, const v8::AccessorInfo& args);
 252     static v8::Handle<v8::Value> nodeValue(v8::Local<v8::String>, const v8::AccessorInfo& args);
 253     static v8::Handle<v8::Value> nodeType(v8::Local<v8::String>, const v8::AccessorInfo& args);
 254
 255     static v8::Handle<v8::Value> parentNode(v8::Local<v8::String>, const v8::AccessorInfo& args);
 256     static v8::Handle<v8::Value> childNodes(v8::Local<v8::String>, const v8::AccessorInfo& args);
 257     static v8::Handle<v8::Value> firstChild(v8::Local<v8::String>, const v8::AccessorInfo& args);
 258     static v8::Handle<v8::Value> lastChild(v8::Local<v8::String>, const v8::AccessorInfo& args);
 259     static v8::Handle<v8::Value> previousSibling(v8::Local<v8::String>, const v8::AccessorInfo& args);
 260     static v8::Handle<v8::Value> nextSibling(v8::Local<v8::String>, const v8::AccessorInfo& args);
 261     static v8::Handle<v8::Value> attributes(v8::Local<v8::String>, const v8::AccessorInfo& args);
 262
 263     //static v8::Handle<v8::Value> ownerDocument(v8::Local<v8::String>, const v8::AccessorInfo& args);
 264     //static v8::Handle<v8::Value> namespaceURI(v8::Local<v8::String>, const v8::AccessorInfo& args);
 265     //static v8::Handle<v8::Value> prefix(v8::Local<v8::String>, const v8::AccessorInfo& args);
 266     //static v8::Handle<v8::Value> localName(v8::Local<v8::String>, const v8::AccessorInfo& args);
 267     //static v8::Handle<v8::Value> baseURI(v8::Local<v8::String>, const v8::AccessorInfo& args);
 268     //static v8::Handle<v8::Value> textContent(v8::Local<v8::String>, const v8::AccessorInfo& args);
 269
 270     // C++ API
 271     static v8::Handle<v8::Object> prototype(QV8Engine *);
 272     static v8::Handle<v8::Value> create(QV8Engine *, NodeImpl *);
 273
 274     Node();
 275     Node(const Node &o);
 276     ~Node();
 277     bool isNull() const;
 278
 279     NodeImpl *d;
 280
 281 private:
 282     Node &operator=(const Node &);
 283 };
 284
 285 class Element : public Node
 286 {
 287 public:
 288     // C++ API
 289     static v8::Handle<v8::Object> prototype(QV8Engine *);
 290 };
 291
 292 class Attr : public Node
 293 {
 294 public:
 295     // JS API
 296     static v8::Handle<v8::Value> name(v8::Local<v8::String>, const v8::AccessorInfo& args);
 297     static v8::Handle<v8::Value> specified(v8::Local<v8::String>, const v8::AccessorInfo& args);
 298     static v8::Handle<v8::Value> value(v8::Local<v8::String>, const v8::AccessorInfo& args);
 299     static v8::Handle<v8::Value> ownerElement(v8::Local<v8::String>, const v8::AccessorInfo& args);
 300     static v8::Handle<v8::Value> schemaTypeInfo(v8::Local<v8::String>, const v8::AccessorInfo& args);
 301     static v8::Handle<v8::Value> isId(v8::Local<v8::String>, const v8::AccessorInfo& args);
 302
 303     // C++ API
 304     static v8::Handle<v8::Object> prototype(QV8Engine *);
 305 };
 306
 307 class CharacterData : public Node
 308 {
 309 public:
 310     // JS API
 311     static v8::Handle<v8::Value> length(v8::Local<v8::String>, const v8::AccessorInfo& args);
 312
 313     // C++ API
 314     static v8::Handle<v8::Object> prototype(QV8Engine *);
 315 };
 316
 317 class Text : public CharacterData
 318 {
 319 public:
 320     // JS API
 321     static v8::Handle<v8::Value> isElementContentWhitespace(v8::Local<v8::String>, const v8::AccessorInfo& args);
 322     static v8::Handle<v8::Value> wholeText(v8::Local<v8::String>, const v8::AccessorInfo& args);
 323
 324     // C++ API
 325     static v8::Handle<v8::Object> prototype(QV8Engine *);
 326 };
 327
 328 class CDATA : public Text
 329 {
 330 public:
 331     // C++ API
 332     static v8::Handle<v8::Object> prototype(QV8Engine *);
 333 };
 334
 335 class Document : public Node
 336 {
 337 public:
 338     // JS API
 339     static v8::Handle<v8::Value> xmlVersion(v8::Local<v8::String>, const v8::AccessorInfo& args);
 340     static v8::Handle<v8::Value> xmlEncoding(v8::Local<v8::String>, const v8::AccessorInfo& args);
 341     static v8::Handle<v8::Value> xmlStandalone(v8::Local<v8::String>, const v8::AccessorInfo& args);
 342     static v8::Handle<v8::Value> documentElement(v8::Local<v8::String>, const v8::AccessorInfo& args);
 343
 344     // C++ API
 345     static v8::Handle<v8::Object> prototype(QV8Engine *);
 346     static v8::Handle<v8::Value> load(QV8Engine *engine, const QByteArray &data);
 347 };
 348
 349 }
 350
 351 class QDeclarativeDOMNodeResource : public QV8ObjectResource, public Node
 352 {
 353     V8_RESOURCE_TYPE(DOMNodeType);
 354 public:
 355     QDeclarativeDOMNodeResource(QV8Engine *e);
 356
 357     QList<NodeImpl *> *list; // Only used in NamedNodeMap
 358 };
 359
 360 QDeclarativeDOMNodeResource::QDeclarativeDOMNodeResource(QV8Engine *e)
 361 : QV8ObjectResource(e), list(0)
 362 {
 363 }
 364
 365 QT_END_NAMESPACE
 366
 367 Q_DECLARE_METATYPE(Node)
 368 Q_DECLARE_METATYPE(NodeList)
 369 Q_DECLARE_METATYPE(NamedNodeMap)
 370
 371 QT_BEGIN_NAMESPACE
 372
 373 void NodeImpl::addref()
 374 {
 375     A(document);
 376 }
 377
 378 void NodeImpl::release()
 379 {
 380     D(document);
 381 }
 382
 383 v8::Handle<v8::Value> Node::nodeName(v8::Local<v8::String>, const v8::AccessorInfo &args)
 384 {
 385     QDeclarativeDOMNodeResource *r = v8_resource_cast<QDeclarativeDOMNodeResource>(args.This());
 386     if (!r) return v8::Undefined();
 387     QV8Engine *engine = V8ENGINE();
 388
 389     switch (r->d->type) {
 390     case NodeImpl::Document:
 391         return v8::String::New("#document");
 392     case NodeImpl::CDATA:
 393         return v8::String::New("#cdata-section");
 394     case NodeImpl::Text:
 395         return v8::String::New("#text");
 396     default:
 397         return engine->toString(r->d->name);
 398     }
 399 }
 400
 401 v8::Handle<v8::Value> Node::nodeValue(v8::Local<v8::String>, const v8::AccessorInfo &args)
 402 {
 403     QDeclarativeDOMNodeResource *r = v8_resource_cast<QDeclarativeDOMNodeResource>(args.This());
 404     if (!r) return v8::Undefined();
 405     QV8Engine *engine = V8ENGINE();
 406
 407     if (r->d->type == NodeImpl::Document ||
 408         r->d->type == NodeImpl::DocumentFragment ||
 409         r->d->type == NodeImpl::DocumentType ||
 410         r->d->type == NodeImpl::Element ||
 411         r->d->type == NodeImpl::Entity ||
 412         r->d->type == NodeImpl::EntityReference ||
 413         r->d->type == NodeImpl::Notation)
 414         return v8::Null();
 415
 416     return engine->toString(r->d->data);
 417 }
 418
 419 v8::Handle<v8::Value> Node::nodeType(v8::Local<v8::String>, const v8::AccessorInfo &args)
 420 {
 421     QDeclarativeDOMNodeResource *r = v8_resource_cast<QDeclarativeDOMNodeResource>(args.This());
 422     if (!r) return v8::Undefined();
 423     return v8::Integer::New(r->d->type);
 424 }
 425
 426 v8::Handle<v8::Value> Node::parentNode(v8::Local<v8::String>, const v8::AccessorInfo &args)
 427 {
 428     QDeclarativeDOMNodeResource *r = v8_resource_cast<QDeclarativeDOMNodeResource>(args.This());
 429     if (!r) return v8::Undefined();
 430     QV8Engine *engine = V8ENGINE();
 431
 432     if (r->d->parent) return Node::create(engine, r->d->parent);
 433     else return v8::Null();
 434 }
 435
 436 v8::Handle<v8::Value> Node::childNodes(v8::Local<v8::String>, const v8::AccessorInfo &args)
 437 {
 438     QDeclarativeDOMNodeResource *r = v8_resource_cast<QDeclarativeDOMNodeResource>(args.This());
 439     if (!r) return v8::Undefined();
 440     QV8Engine *engine = V8ENGINE();
 441
 442     return NodeList::create(engine, r->d);
 443 }
 444
 445 v8::Handle<v8::Value> Node::firstChild(v8::Local<v8::String>, const v8::AccessorInfo &args)
 446 {
 447     QDeclarativeDOMNodeResource *r = v8_resource_cast<QDeclarativeDOMNodeResource>(args.This());
 448     if (!r) return v8::Undefined();
 449     QV8Engine *engine = V8ENGINE();
 450
 451     if (r->d->children.isEmpty()) return v8::Null();
 452     else return Node::create(engine, r->d->children.first());
 453 }
 454
 455 v8::Handle<v8::Value> Node::lastChild(v8::Local<v8::String>, const v8::AccessorInfo &args)
 456 {
 457     QDeclarativeDOMNodeResource *r = v8_resource_cast<QDeclarativeDOMNodeResource>(args.This());
 458     if (!r) return v8::Undefined();
 459     QV8Engine *engine = V8ENGINE();
 460
 461     if (r->d->children.isEmpty()) return v8::Null();
 462     else return Node::create(engine, r->d->children.last());
 463 }
 464
 465 v8::Handle<v8::Value> Node::previousSibling(v8::Local<v8::String>, const v8::AccessorInfo &args)
 466 {
 467     QDeclarativeDOMNodeResource *r = v8_resource_cast<QDeclarativeDOMNodeResource>(args.This());
 468     if (!r) return v8::Undefined();
 469     QV8Engine *engine = V8ENGINE();
 470
 471     if (!r->d->parent) return v8::Null();
 472
 473     for (int ii = 0; ii < r->d->parent->children.count(); ++ii) {
 474         if (r->d->parent->children.at(ii) == r->d) {
 475             if (ii == 0) return v8::Null();
 476             else return Node::create(engine, r->d->parent->children.at(ii - 1));
 477         }
 478     }
 479
 480     return v8::Null();
 481 }
 482
 483 v8::Handle<v8::Value> Node::nextSibling(v8::Local<v8::String>, const v8::AccessorInfo &args)
 484 {
 485     QDeclarativeDOMNodeResource *r = v8_resource_cast<QDeclarativeDOMNodeResource>(args.This());
 486     if (!r) return v8::Undefined();
 487     QV8Engine *engine = V8ENGINE();
 488
 489     if (!r->d->parent) return v8::Null();
 490
 491     for (int ii = 0; ii < r->d->parent->children.count(); ++ii) {
 492         if (r->d->parent->children.at(ii) == r->d) {
 493             if ((ii + 1) == r->d->parent->children.count()) return v8::Null();
 494             else return Node::create(engine, r->d->parent->children.at(ii + 1));
 495         }
 496     }
 497
 498     return v8::Null();
 499 }
 500
 501 v8::Handle<v8::Value> Node::attributes(v8::Local<v8::String>, const v8::AccessorInfo &args)
 502 {
 503     QDeclarativeDOMNodeResource *r = v8_resource_cast<QDeclarativeDOMNodeResource>(args.This());
 504     if (!r) return v8::Undefined();
 505     QV8Engine *engine = V8ENGINE();
 506
 507     if (r->d->type != NodeImpl::Element)
 508         return v8::Null();
 509     else
 510         return NamedNodeMap::create(engine, r->d, &r->d->attributes);
 511 }
 512
 513 v8::Handle<v8::Object> Node::prototype(QV8Engine *engine)
 514 {
 515     QDeclarativeXMLHttpRequestData *d = xhrdata(engine);
 516     if (d->nodePrototype.IsEmpty()) {
 517         d->nodePrototype = qPersistentNew<v8::Object>(v8::Object::New());
 518         d->nodePrototype->SetAccessor(v8::String::New("nodeName"), nodeName,
 519                                       0, v8::External::Wrap(engine));
 520         d->nodePrototype->SetAccessor(v8::String::New("nodeValue"), nodeValue,
 521                                       0, v8::External::Wrap(engine));
 522         d->nodePrototype->SetAccessor(v8::String::New("nodeType"), nodeType,
 523                                       0, v8::External::Wrap(engine));
 524         d->nodePrototype->SetAccessor(v8::String::New("parentNode"), parentNode,
 525                                       0, v8::External::Wrap(engine));
 526         d->nodePrototype->SetAccessor(v8::String::New("childNodes"), childNodes,
 527                                       0, v8::External::Wrap(engine));
 528         d->nodePrototype->SetAccessor(v8::String::New("firstChild"), firstChild,
 529                                       0, v8::External::Wrap(engine));
 530         d->nodePrototype->SetAccessor(v8::String::New("lastChild"), lastChild,
 531                                       0, v8::External::Wrap(engine));
 532         d->nodePrototype->SetAccessor(v8::String::New("previousSibling"), previousSibling,
 533                                       0, v8::External::Wrap(engine));
 534         d->nodePrototype->SetAccessor(v8::String::New("nextSibling"), nextSibling,
 535                                       0, v8::External::Wrap(engine));
 536         d->nodePrototype->SetAccessor(v8::String::New("attributes"), attributes,
 537                                       0, v8::External::Wrap(engine));
 538         engine->freezeObject(d->nodePrototype);
 539     }
 540     return d->nodePrototype;
 541 }
 542
 543 v8::Handle<v8::Value> Node::create(QV8Engine *engine, NodeImpl *data)
 544 {
 545     QDeclarativeXMLHttpRequestData *d = xhrdata(engine);
 546     v8::Local<v8::Object> instance = d->newNode();
 547
 548     switch (data->type) {
 549     case NodeImpl::Attr:
 550         instance->SetPrototype(Attr::prototype(engine));
 551         break;
 552     case NodeImpl::Comment:
 553     case NodeImpl::Document:
 554     case NodeImpl::DocumentFragment:
 555     case NodeImpl::DocumentType:
 556     case NodeImpl::Entity:
 557     case NodeImpl::EntityReference:
 558     case NodeImpl::Notation:
 559     case NodeImpl::ProcessingInstruction:
 560         return v8::Undefined();
 561     case NodeImpl::CDATA:
 562         instance->SetPrototype(CDATA::prototype(engine));
 563         break;
 564     case NodeImpl::Text:
 565         instance->SetPrototype(Text::prototype(engine));
 566         break;
 567     case NodeImpl::Element:
 568         instance->SetPrototype(Element::prototype(engine));
 569         break;
 570     }
 571
 572     QDeclarativeDOMNodeResource *r = new QDeclarativeDOMNodeResource(engine);
 573     r->d = data;
 574     if (data) A(data);
 575     instance->SetExternalResource(r);
 576
 577     return instance;
 578 }
 579
 580 v8::Handle<v8::Object> Element::prototype(QV8Engine *engine)
 581 {
 582     QDeclarativeXMLHttpRequestData *d = xhrdata(engine);
 583     if (d->elementPrototype.IsEmpty()) {
 584         d->elementPrototype = qPersistentNew<v8::Object>(v8::Object::New());
 585         d->elementPrototype->SetPrototype(Node::prototype(engine));
 586         d->elementPrototype->SetAccessor(v8::String::New("tagName"), nodeName,
 587                                          0, v8::External::Wrap(engine));
 588         engine->freezeObject(d->elementPrototype);
 589     }
 590     return d->elementPrototype;
 591 }
 592
 593 v8::Handle<v8::Object> Attr::prototype(QV8Engine *engine)
 594 {
 595     QDeclarativeXMLHttpRequestData *d = xhrdata(engine);
 596     if (d->attrPrototype.IsEmpty()) {
 597         d->attrPrototype = qPersistentNew<v8::Object>(v8::Object::New());
 598         d->attrPrototype->SetPrototype(Node::prototype(engine));
 599         d->attrPrototype->SetAccessor(v8::String::New("name"), name,
 600                                       0, v8::External::Wrap(engine));
 601         d->attrPrototype->SetAccessor(v8::String::New("value"), value,
 602                                       0, v8::External::Wrap(engine));
 603         d->attrPrototype->SetAccessor(v8::String::New("ownerElement"), ownerElement,
 604                                       0, v8::External::Wrap(engine));
 605         engine->freezeObject(d->attrPrototype);
 606     }
 607     return d->attrPrototype;
 608 }
 609
 610 v8::Handle<v8::Value> Attr::name(v8::Local<v8::String>, const v8::AccessorInfo &args)
 611 {
 612     QDeclarativeDOMNodeResource *r = v8_resource_cast<QDeclarativeDOMNodeResource>(args.This());
 613     if (!r) return v8::Undefined();
 614     QV8Engine *engine = V8ENGINE();
 615
 616     return engine->toString(r->d->name);
 617 }
 618
 619 v8::Handle<v8::Value> Attr::value(v8::Local<v8::String>, const v8::AccessorInfo &args)
 620 {
 621     QDeclarativeDOMNodeResource *r = v8_resource_cast<QDeclarativeDOMNodeResource>(args.This());
 622     if (!r) return v8::Undefined();
 623     QV8Engine *engine = V8ENGINE();
 624
 625     return engine->toString(r->d->data);
 626 }
 627
 628 v8::Handle<v8::Value> Attr::ownerElement(v8::Local<v8::String>, const v8::AccessorInfo &args)
 629 {
 630     QDeclarativeDOMNodeResource *r = v8_resource_cast<QDeclarativeDOMNodeResource>(args.This());
 631     if (!r) return v8::Undefined();
 632     QV8Engine *engine = V8ENGINE();
 633
 634     return Node::create(engine, r->d->parent);
 635 }
 636
 637 v8::Handle<v8::Value> CharacterData::length(v8::Local<v8::String>, const v8::AccessorInfo &args)
 638 {
 639     QDeclarativeDOMNodeResource *r = v8_resource_cast<QDeclarativeDOMNodeResource>(args.This());
 640     if (!r) return v8::Undefined();
 641     QV8Engine *engine = V8ENGINE();
 642
 643     return v8::Integer::New(r->d->data.length());
 644 }
 645
 646 v8::Handle<v8::Object> CharacterData::prototype(QV8Engine *engine)
 647 {
 648     QDeclarativeXMLHttpRequestData *d = xhrdata(engine);
 649     if (d->characterDataPrototype.IsEmpty()) {
 650         d->characterDataPrototype = qPersistentNew<v8::Object>(v8::Object::New());
 651         d->characterDataPrototype->SetPrototype(Node::prototype(engine));
 652         d->characterDataPrototype->SetAccessor(v8::String::New("data"), nodeValue,
 653                                                0, v8::External::Wrap(engine));
 654         d->characterDataPrototype->SetAccessor(v8::String::New("length"), length,
 655                                                0, v8::External::Wrap(engine));
 656         engine->freezeObject(d->characterDataPrototype);
 657     }
 658     return d->characterDataPrototype;
 659 }
 660
 661 v8::Handle<v8::Value> Text::isElementContentWhitespace(v8::Local<v8::String>, const v8::AccessorInfo &args)
 662 {
 663     QDeclarativeDOMNodeResource *r = v8_resource_cast<QDeclarativeDOMNodeResource>(args.This());
 664     if (!r) return v8::Undefined();
 665     QV8Engine *engine = V8ENGINE();
 666
 667     return v8::Boolean::New(r->d->data.trimmed().isEmpty());
 668 }
 669
 670 v8::Handle<v8::Value> Text::wholeText(v8::Local<v8::String>, const v8::AccessorInfo &args)
 671 {
 672     QDeclarativeDOMNodeResource *r = v8_resource_cast<QDeclarativeDOMNodeResource>(args.This());
 673     if (!r) return v8::Undefined();
 674     QV8Engine *engine = V8ENGINE();
 675
 676     return engine->toString(r->d->data);
 677 }
 678
 679 v8::Handle<v8::Object> Text::prototype(QV8Engine *engine)
 680 {
 681     QDeclarativeXMLHttpRequestData *d = xhrdata(engine);
 682     if (d->textPrototype.IsEmpty()) {
 683         d->textPrototype = qPersistentNew<v8::Object>(v8::Object::New());
 684         d->textPrototype->SetPrototype(CharacterData::prototype(engine));
 685         d->textPrototype->SetAccessor(v8::String::New("isElementContentWhitespace"), isElementContentWhitespace,
 686                                                0, v8::External::Wrap(engine));
 687         d->textPrototype->SetAccessor(v8::String::New("wholeText"), wholeText,
 688                                                0, v8::External::Wrap(engine));
 689         engine->freezeObject(d->textPrototype);
 690     }
 691     return d->textPrototype;
 692 }
 693
 694 v8::Handle<v8::Object> CDATA::prototype(QV8Engine *engine)
 695 {
 696     QDeclarativeXMLHttpRequestData *d = xhrdata(engine);
 697     if (d->cdataPrototype.IsEmpty()) {
 698         d->cdataPrototype = qPersistentNew<v8::Object>(v8::Object::New());
 699         d->cdataPrototype->SetPrototype(Text::prototype(engine));
 700         engine->freezeObject(d->cdataPrototype);
 701     }
 702     return d->cdataPrototype;
 703 }
 704
 705 v8::Handle<v8::Object> Document::prototype(QV8Engine *engine)
 706 {
 707     QDeclarativeXMLHttpRequestData *d = xhrdata(engine);
 708     if (d->documentPrototype.IsEmpty()) {
 709         d->documentPrototype = qPersistentNew<v8::Object>(v8::Object::New());
 710         d->documentPrototype->SetPrototype(Node::prototype(engine));
 711         d->documentPrototype->SetAccessor(v8::String::New("xmlVersion"), xmlVersion,
 712                                           0, v8::External::Wrap(engine));
 713         d->documentPrototype->SetAccessor(v8::String::New("xmlEncoding"), xmlEncoding,
 714                                           0, v8::External::Wrap(engine));
 715         d->documentPrototype->SetAccessor(v8::String::New("xmlStandalone"), xmlStandalone,
 716                                           0, v8::External::Wrap(engine));
 717         d->documentPrototype->SetAccessor(v8::String::New("documentElement"), documentElement,
 718                                           0, v8::External::Wrap(engine));
 719         engine->freezeObject(d->documentPrototype);
 720     }
 721     return d->documentPrototype;
 722 }
 723
 724 v8::Handle<v8::Value> Document::load(QV8Engine *engine, const QByteArray &data)
 725 {
 726     Q_ASSERT(engine);
 727
 728     DocumentImpl *document = 0;
 729     QStack<NodeImpl *> nodeStack;
 730
 731     QXmlStreamReader reader(data);
 732
 733     while (!reader.atEnd()) {
 734         switch (reader.readNext()) {
 735         case QXmlStreamReader::NoToken:
 736             break;
 737         case QXmlStreamReader::Invalid:
 738             break;
 739         case QXmlStreamReader::StartDocument:
 740             Q_ASSERT(!document);
 741             document = new DocumentImpl;
 742             document->document = document;
 743             document->version = reader.documentVersion().toString();
 744             document->encoding = reader.documentEncoding().toString();
 745             document->isStandalone = reader.isStandaloneDocument();
 746             break;
 747         case QXmlStreamReader::EndDocument:
 748             break;
 749         case QXmlStreamReader::StartElement:
 750         {
 751             Q_ASSERT(document);
 752             NodeImpl *node = new NodeImpl;
 753             node->document = document;
 754             node->namespaceUri = reader.namespaceUri().toString();
 755             node->name = reader.name().toString();
 756             if (nodeStack.isEmpty()) {
 757                 document->root = node;
 758             } else {
 759                 node->parent = nodeStack.top();
 760                 node->parent->children.append(node);
 761             }
 762             nodeStack.append(node);
 763
 764             foreach (const QXmlStreamAttribute &a, reader.attributes()) {
 765                 NodeImpl *attr = new NodeImpl;
 766                 attr->document = document;
 767                 attr->type = NodeImpl::Attr;
 768                 attr->namespaceUri = a.namespaceUri().toString();
 769                 attr->name = a.name().toString();
 770                 attr->data = a.value().toString();
 771                 attr->parent = node;
 772                 node->attributes.append(attr);
 773             }
 774         }
 775             break;
 776         case QXmlStreamReader::EndElement:
 777             nodeStack.pop();
 778             break;
 779         case QXmlStreamReader::Characters:
 780         {
 781             NodeImpl *node = new NodeImpl;
 782             node->document = document;
 783             node->type = reader.isCDATA()?NodeImpl::CDATA:NodeImpl::Text;
 784             node->parent = nodeStack.top();
 785             node->parent->children.append(node);
 786             node->data = reader.text().toString();
 787         }
 788             break;
 789         case QXmlStreamReader::Comment:
 790             break;
 791         case QXmlStreamReader::DTD:
 792             break;
 793         case QXmlStreamReader::EntityReference:
 794             break;
 795         case QXmlStreamReader::ProcessingInstruction:
 796             break;
 797         }
 798     }
 799
 800     if (!document || reader.hasError()) {
 801         if (document) D(document);
 802         return v8::Null();
 803     }
 804
 805     v8::Local<v8::Object> instance = xhrdata(engine)->newNode();
 806     QDeclarativeDOMNodeResource *r = new QDeclarativeDOMNodeResource(engine);
 807     r->d = document;
 808     instance->SetExternalResource(r);
 809     instance->SetPrototype(Document::prototype(engine));
 810     return instance;
 811 }
 812
 813 Node::Node()
 814 : d(0)
 815 {
 816 }
 817
 818 Node::Node(const Node &o)
 819 : d(o.d)
 820 {
 821     if (d) A(d);
 822 }
 823
 824 Node::~Node()
 825 {
 826     if (d) D(d);
 827 }
 828
 829 bool Node::isNull() const
 830 {
 831     return d == 0;
 832 }
 833
 834 v8::Handle<v8::Value> NamedNodeMap::length(v8::Local<v8::String>, const v8::AccessorInfo &args)
 835 {
 836     QDeclarativeDOMNodeResource *r = v8_resource_cast<QDeclarativeDOMNodeResource>(args.This());
 837     if (!r) return v8::Undefined();
 838     QV8Engine *engine = V8ENGINE();
 839
 840     return v8::Integer::New(r->list->count());
 841 }
 842
 843 v8::Handle<v8::Value> NamedNodeMap::indexed(uint32_t index, const v8::AccessorInfo& args)
 844 {
 845     QDeclarativeDOMNodeResource *r = v8_resource_cast<QDeclarativeDOMNodeResource>(args.This());
 846     if (!r || !r->list) return v8::Undefined();
 847     QV8Engine *engine = V8ENGINE();
 848
 849     if (index < r->list->count()) {
 850         return Node::create(engine, r->list->at(index));
 851     } else {
 852         return v8::Undefined();
 853     }
 854 }
 855
 856 v8::Handle<v8::Value> NamedNodeMap::named(v8::Local<v8::String> property, const v8::AccessorInfo& args)
 857 {
 858     QDeclarativeDOMNodeResource *r = v8_resource_cast<QDeclarativeDOMNodeResource>(args.This());
 859     if (!r || !r->list) return v8::Undefined();
 860     QV8Engine *engine = V8ENGINE();
 861
 862     QString str = engine->toString(property);
 863     for (int ii = 0; ii < r->list->count(); ++ii) {
 864         if (r->list->at(ii)->name == str) {
 865             return Node::create(engine, r->list->at(ii));
 866         }
 867     }
 868
 869     return v8::Undefined();
 870 }
 871
 872 v8::Handle<v8::Object> NamedNodeMap::prototype(QV8Engine *engine)
 873 {
 874     QDeclarativeXMLHttpRequestData *d = xhrdata(engine);
 875     if (d->namedNodeMapPrototype.IsEmpty()) {
 876         v8::Local<v8::ObjectTemplate> ot = v8::ObjectTemplate::New();
 877         ot->SetAccessor(v8::String::New("length"), length, 0, v8::External::Wrap(engine));
 878         ot->SetIndexedPropertyHandler(indexed, 0, 0, 0, 0, v8::External::Wrap(engine));
 879         ot->SetFallbackPropertyHandler(named, 0, 0, 0, 0, v8::External::Wrap(engine));
 880         d->namedNodeMapPrototype = qPersistentNew<v8::Object>(ot->NewInstance());
 881         engine->freezeObject(d->namedNodeMapPrototype);
 882     }
 883     return d->namedNodeMapPrototype;
 884 }
 885
 886 v8::Handle<v8::Value> NamedNodeMap::create(QV8Engine *engine, NodeImpl *data, QList<NodeImpl *> *list)
 887 {
 888     QDeclarativeXMLHttpRequestData *d = xhrdata(engine);
 889     v8::Local<v8::Object> instance = d->newNode();
 890     instance->SetPrototype(NamedNodeMap::prototype(engine));
 891     QDeclarativeDOMNodeResource *r = new QDeclarativeDOMNodeResource(engine);
 892     r->d = data;
 893     r->list = list;
 894     if (data) A(data);
 895     instance->SetExternalResource(r);
 896     return instance;
 897 }
 898
 899 v8::Handle<v8::Value> NodeList::indexed(uint32_t index, const v8::AccessorInfo& args)
 900 {
 901     QDeclarativeDOMNodeResource *r = v8_resource_cast<QDeclarativeDOMNodeResource>(args.This());
 902     if (!r) return v8::Undefined();
 903     QV8Engine *engine = V8ENGINE();
 904
 905     if (index < r->d->children.count()) {
 906         return Node::create(engine, r->d->children.at(index));
 907     } else {
 908         return v8::Undefined();
 909     }
 910 }
 911
 912 v8::Handle<v8::Value> NodeList::length(v8::Local<v8::String>, const v8::AccessorInfo& args)
 913 {
 914     QDeclarativeDOMNodeResource *r = v8_resource_cast<QDeclarativeDOMNodeResource>(args.This());
 915     if (!r) return v8::Undefined();
 916     QV8Engine *engine = V8ENGINE();
 917
 918     return v8::Integer::New(r->d->children.count());
 919 }
 920
 921 v8::Handle<v8::Object> NodeList::prototype(QV8Engine *engine)
 922 {
 923     QDeclarativeXMLHttpRequestData *d = xhrdata(engine);
 924     if (d->nodeListPrototype.IsEmpty()) {
 925         v8::Local<v8::ObjectTemplate> ot = v8::ObjectTemplate::New();
 926         ot->SetAccessor(v8::String::New("length"), length, 0, v8::External::Wrap(engine));
 927         ot->SetIndexedPropertyHandler(indexed, 0, 0, 0, 0, v8::External::Wrap(engine));
 928         d->nodeListPrototype = qPersistentNew<v8::Object>(ot->NewInstance());
 929         engine->freezeObject(d->nodeListPrototype);
 930     }
 931     return d->nodeListPrototype;
 932 }
 933
 934 v8::Handle<v8::Value> NodeList::create(QV8Engine *engine, NodeImpl *data)
 935 {
 936     QDeclarativeXMLHttpRequestData *d = xhrdata(engine);
 937     v8::Local<v8::Object> instance = d->newNode();
 938     instance->SetPrototype(NodeList::prototype(engine));
 939     QDeclarativeDOMNodeResource *r = new QDeclarativeDOMNodeResource(engine);
 940     r->d = data;
 941     if (data) A(data);
 942     instance->SetExternalResource(r);
 943     return instance;
 944 }
 945
 946 v8::Handle<v8::Value> Document::documentElement(v8::Local<v8::String>, const v8::AccessorInfo& args)
 947 {
 948     QDeclarativeDOMNodeResource *r = v8_resource_cast<QDeclarativeDOMNodeResource>(args.This());
 949     if (!r || r->d->type != NodeImpl::Document) return v8::Undefined();
 950     QV8Engine *engine = V8ENGINE();
 951
 952     return Node::create(engine, static_cast<DocumentImpl *>(r->d)->root);
 953 }
 954
 955 v8::Handle<v8::Value> Document::xmlStandalone(v8::Local<v8::String>, const v8::AccessorInfo& args)
 956 {
 957     QDeclarativeDOMNodeResource *r = v8_resource_cast<QDeclarativeDOMNodeResource>(args.This());
 958     if (!r || r->d->type != NodeImpl::Document) return v8::Undefined();
 959     QV8Engine *engine = V8ENGINE();
 960
 961     return v8::Boolean::New(static_cast<DocumentImpl *>(r->d)->isStandalone);
 962 }
 963
 964 v8::Handle<v8::Value> Document::xmlVersion(v8::Local<v8::String>, const v8::AccessorInfo& args)
 965 {
 966     QDeclarativeDOMNodeResource *r = v8_resource_cast<QDeclarativeDOMNodeResource>(args.This());
 967     if (!r || r->d->type != NodeImpl::Document) return v8::Undefined();
 968     QV8Engine *engine = V8ENGINE();
 969
 970     return engine->toString(static_cast<DocumentImpl *>(r->d)->version);
 971 }
 972
 973 v8::Handle<v8::Value> Document::xmlEncoding(v8::Local<v8::String>, const v8::AccessorInfo& args)
 974 {
 975     QDeclarativeDOMNodeResource *r = v8_resource_cast<QDeclarativeDOMNodeResource>(args.This());
 976     if (!r || r->d->type != NodeImpl::Document) return v8::Undefined();
 977     QV8Engine *engine = V8ENGINE();
 978
 979     return engine->toString(static_cast<DocumentImpl *>(r->d)->encoding);
 980 }
 981
 982 class QDeclarativeXMLHttpRequest : public QObject, public QV8ObjectResource
 983 {
 984 Q_OBJECT
 985 V8_RESOURCE_TYPE(XMLHttpRequestType)
 986 public:
 987     enum State { Unsent = 0,
 988                  Opened = 1, HeadersReceived = 2,
 989                  Loading = 3, Done = 4 };
 990
 991     QDeclarativeXMLHttpRequest(QV8Engine *engine, QNetworkAccessManager *manager);
 992     virtual ~QDeclarativeXMLHttpRequest();
 993
 994     bool sendFlag() const;
 995     bool errorFlag() const;
 996     quint32 readyState() const;
 997     int replyStatus() const;
 998     QString replyStatusText() const;
 999
1000     v8::Handle<v8::Value> open(v8::Handle<v8::Object> me, const QString &, const QUrl &);
1001     v8::Handle<v8::Value> send(v8::Handle<v8::Object> me, const QByteArray &);
1002     v8::Handle<v8::Value> abort(v8::Handle<v8::Object> me);
1003
1004     void addHeader(const QString &, const QString &);
1005     QString header(const QString &name);
1006     QString headers();
1007
1008
1009     QString responseBody();
1010     const QByteArray & rawResponseBody() const;
1011     bool receivedXml() const;
1012 private slots:
1013     void downloadProgress(qint64);
1014     void error(QNetworkReply::NetworkError);
1015     void finished();
1016
1017 private:
1018     void requestFromUrl(const QUrl &url);
1019
1020     State m_state;
1021     bool m_errorFlag;
1022     bool m_sendFlag;
1023     QString m_method;
1024     QUrl m_url;
1025     QByteArray m_responseEntityBody;
1026     QByteArray m_data;
1027     int m_redirectCount;
1028
1029     typedef QPair<QByteArray, QByteArray> HeaderPair;
1030     typedef QList<HeaderPair> HeadersList;
1031     HeadersList m_headersList;
1032     void fillHeadersList();
1033
1034     bool m_gotXml;
1035     QByteArray m_mime;
1036     QByteArray m_charset;
1037     QTextCodec *m_textCodec;
1038 #ifndef QT_NO_TEXTCODEC
1039     QTextCodec* findTextCodec() const;
1040 #endif
1041     void readEncoding();
1042
1043     v8::Handle<v8::Object> getMe() const;
1044     void setMe(v8::Handle<v8::Object> me);
1045     v8::Persistent<v8::Object> m_me;
1046
1047     void dispatchCallback(v8::Handle<v8::Object> me);
1048     void printError(v8::Handle<v8::Message>);
1049
1050     int m_status;
1051     QString m_statusText;
1052     QNetworkRequest m_request;
1053     QDeclarativeGuard<QNetworkReply> m_network;
1054     void destroyNetwork();
1055
1056     QNetworkAccessManager *m_nam;
1057     QNetworkAccessManager *networkAccessManager() { return m_nam; }
1058 };
1059
1060 QDeclarativeXMLHttpRequest::QDeclarativeXMLHttpRequest(QV8Engine *engine, QNetworkAccessManager *manager)
1061 : QV8ObjectResource(engine), m_state(Unsent), m_errorFlag(false), m_sendFlag(false),
1062   m_redirectCount(0), m_gotXml(false), m_textCodec(0), m_network(0), m_nam(manager)
1063 {
1064 }
1065
1066 QDeclarativeXMLHttpRequest::~QDeclarativeXMLHttpRequest()
1067 {
1068     destroyNetwork();
1069 }
1070
1071 bool QDeclarativeXMLHttpRequest::sendFlag() const
1072 {
1073     return m_sendFlag;
1074 }
1075
1076 bool QDeclarativeXMLHttpRequest::errorFlag() const
1077 {
1078     return m_errorFlag;
1079 }
1080
1081 quint32 QDeclarativeXMLHttpRequest::readyState() const
1082 {
1083     return m_state;
1084 }
1085
1086 int QDeclarativeXMLHttpRequest::replyStatus() const
1087 {
1088     return m_status;
1089 }
1090
1091 QString QDeclarativeXMLHttpRequest::replyStatusText() const
1092 {
1093     return m_statusText;
1094 }
1095
1096 v8::Handle<v8::Value> QDeclarativeXMLHttpRequest::open(v8::Handle<v8::Object> me, const QString &method,
1097                                                        const QUrl &url)
1098 {
1099     destroyNetwork();
1100     m_sendFlag = false;
1101     m_errorFlag = false;
1102     m_responseEntityBody = QByteArray();
1103     m_method = method;
1104     m_url = url;
1105     m_state = Opened;
1106     dispatchCallback(me);
1107     return v8::Undefined();
1108 }
1109
1110 void QDeclarativeXMLHttpRequest::addHeader(const QString &name, const QString &value)
1111 {
1112     QByteArray utfname = name.toUtf8();
1113
1114     if (m_request.hasRawHeader(utfname)) {
1115         m_request.setRawHeader(utfname, m_request.rawHeader(utfname) + ',' + value.toUtf8());
1116     } else {
1117         m_request.setRawHeader(utfname, value.toUtf8());
1118     }
1119 }
1120
1121 QString QDeclarativeXMLHttpRequest::header(const QString &name)
1122 {
1123     QByteArray utfname = name.toLower().toUtf8();
1124
1125     foreach (const HeaderPair &header, m_headersList) {
1126         if (header.first == utfname)
1127             return QString::fromUtf8(header.second);
1128     }
1129     return QString();
1130 }
1131
1132 QString QDeclarativeXMLHttpRequest::headers()
1133 {
1134     QString ret;
1135
1136     foreach (const HeaderPair &header, m_headersList) {
1137         if (ret.length())
1138             ret.append(QLatin1String("\r\n"));
1139         ret = ret % QString::fromUtf8(header.first) % QLatin1String(": ")
1140                 % QString::fromUtf8(header.second);
1141     }
1142     return ret;
1143 }
1144
1145 void QDeclarativeXMLHttpRequest::fillHeadersList()
1146 {
1147     QList<QByteArray> headerList = m_network->rawHeaderList();
1148
1149     m_headersList.clear();
1150     foreach (const QByteArray &header, headerList) {
1151         HeaderPair pair (header.toLower(), m_network->rawHeader(header));
1152         if (pair.first == "set-cookie" ||
1153             pair.first == "set-cookie2")
1154             continue;
1155
1156         m_headersList << pair;
1157     }
1158 }
1159
1160 void QDeclarativeXMLHttpRequest::requestFromUrl(const QUrl &url)
1161 {
1162     QNetworkRequest request = m_request;
1163     request.setUrl(url);
1164     if(m_method == QLatin1String("POST") ||
1165        m_method == QLatin1String("PUT")) {
1166         QVariant var = request.header(QNetworkRequest::ContentTypeHeader);
1167         if (var.isValid()) {
1168             QString str = var.toString();
1169             int charsetIdx = str.indexOf(QLatin1String("charset="));
1170             if (charsetIdx == -1) {
1171                 // No charset - append
1172                 if (!str.isEmpty()) str.append(QLatin1Char(';'));
1173                 str.append(QLatin1String("charset=UTF-8"));
1174             } else {
1175                 charsetIdx += 8;
1176                 int n = 0;
1177                 int semiColon = str.indexOf(QLatin1Char(';'), charsetIdx);
1178                 if (semiColon == -1) {
1179                     n = str.length() - charsetIdx;
1180                 } else {
1181                     n = semiColon - charsetIdx;
1182                 }
1183
1184                 str.replace(charsetIdx, n, QLatin1String("UTF-8"));
1185             }
1186             request.setHeader(QNetworkRequest::ContentTypeHeader, str);
1187         } else {
1188             request.setHeader(QNetworkRequest::ContentTypeHeader,
1189                               QLatin1String("text/plain;charset=UTF-8"));
1190         }
1191     }
1192
1193     if (xhrDump()) {
1194         qWarning().nospace() << "XMLHttpRequest: " << qPrintable(m_method) << " " << qPrintable(url.toString());
1195         if (!m_data.isEmpty()) {
1196             qWarning().nospace() << "                "
1197                                  << qPrintable(QString::fromUtf8(m_data));
1198         }
1199     }
1200
1201     if (m_method == QLatin1String("GET"))
1202         m_network = networkAccessManager()->get(request);
1203     else if (m_method == QLatin1String("HEAD"))
1204         m_network = networkAccessManager()->head(request);
1205     else if (m_method == QLatin1String("POST"))
1206         m_network = networkAccessManager()->post(request, m_data);
1207     else if (m_method == QLatin1String("PUT"))
1208         m_network = networkAccessManager()->put(request, m_data);
1209     else if (m_method == QLatin1String("DELETE"))
1210         m_network = networkAccessManager()->deleteResource(request);
1211
1212     QObject::connect(m_network, SIGNAL(downloadProgress(qint64,qint64)),
1213                      this, SLOT(downloadProgress(qint64)));
1214     QObject::connect(m_network, SIGNAL(error(QNetworkReply::NetworkError)),
1215                      this, SLOT(error(QNetworkReply::NetworkError)));
1216     QObject::connect(m_network, SIGNAL(finished()),
1217                      this, SLOT(finished()));
1218 }
1219
1220 v8::Handle<v8::Value> QDeclarativeXMLHttpRequest::send(v8::Handle<v8::Object> me, const QByteArray &data)
1221 {
1222     m_errorFlag = false;
1223     m_sendFlag = true;
1224     m_redirectCount = 0;
1225     m_data = data;
1226
1227     setMe(me);
1228
1229     requestFromUrl(m_url);
1230
1231     return v8::Undefined();
1232 }
1233
1234 v8::Handle<v8::Value> QDeclarativeXMLHttpRequest::abort(v8::Handle<v8::Object> me)
1235 {
1236     destroyNetwork();
1237     m_responseEntityBody = QByteArray();
1238     m_errorFlag = true;
1239     m_request = QNetworkRequest();
1240
1241     if (!(m_state == Unsent ||
1242           (m_state == Opened && !m_sendFlag) ||
1243           m_state == Done)) {
1244
1245         m_state = Done;
1246         m_sendFlag = false;
1247         dispatchCallback(me);
1248     }
1249
1250     m_state = Unsent;
1251
1252     return v8::Undefined();
1253 }
1254
1255 v8::Handle<v8::Object> QDeclarativeXMLHttpRequest::getMe() const
1256 {
1257     return m_me;
1258 }
1259
1260 void QDeclarativeXMLHttpRequest::setMe(v8::Handle<v8::Object> me)
1261 {
1262     qPersistentDispose(m_me);
1263
1264     if (!me.IsEmpty())
1265         m_me = qPersistentNew<v8::Object>(me);
1266 }
1267
1268 void QDeclarativeXMLHttpRequest::downloadProgress(qint64 bytes)
1269 {
1270     v8::HandleScope handle_scope;
1271
1272     Q_UNUSED(bytes)
1273     m_status =
1274         m_network->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
1275     m_statusText =
1276         QString::fromUtf8(m_network->attribute(QNetworkRequest::HttpReasonPhraseAttribute).toByteArray());
1277
1278     // ### We assume if this is called the headers are now available
1279     if (m_state < HeadersReceived) {
1280         m_state = HeadersReceived;
1281         fillHeadersList ();
1282         v8::TryCatch tc;
1283         dispatchCallback(m_me);
1284         if (tc.HasCaught()) printError(tc.Message());
1285     }
1286
1287     bool wasEmpty = m_responseEntityBody.isEmpty();
1288     m_responseEntityBody.append(m_network->readAll());
1289     if (wasEmpty && !m_responseEntityBody.isEmpty()) {
1290         m_state = Loading;
1291         v8::TryCatch tc;
1292         dispatchCallback(m_me);
1293         if (tc.HasCaught()) printError(tc.Message());
1294     }
1295 }
1296
1297 static const char *errorToString(QNetworkReply::NetworkError error)
1298 {
1299     int idx = QNetworkReply::staticMetaObject.indexOfEnumerator("NetworkError");
1300     if (idx == -1) return "EnumLookupFailed";
1301
1302     QMetaEnum e = QNetworkReply::staticMetaObject.enumerator(idx);
1303
1304     const char *name = e.valueToKey(error);
1305     if (!name) return "EnumLookupFailed";
1306     else return name;
1307 }
1308
1309 void QDeclarativeXMLHttpRequest::error(QNetworkReply::NetworkError error)
1310 {
1311     v8::HandleScope handle_scope;
1312
1313     Q_UNUSED(error)
1314     m_status =
1315         m_network->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
1316     m_statusText =
1317         QString::fromUtf8(m_network->attribute(QNetworkRequest::HttpReasonPhraseAttribute).toByteArray());
1318
1319     m_responseEntityBody = QByteArray();
1320
1321     m_request = QNetworkRequest();
1322     m_data.clear();
1323     destroyNetwork();
1324
1325     if (xhrDump()) {
1326         qWarning().nospace() << "XMLHttpRequest: ERROR " << qPrintable(m_url.toString());
1327         qWarning().nospace() << "    " << error << " " << errorToString(error) << " " << m_statusText;
1328     }
1329
1330     if (error == QNetworkReply::ContentAccessDenied ||
1331         error == QNetworkReply::ContentOperationNotPermittedError ||
1332         error == QNetworkReply::ContentNotFoundError ||
1333         error == QNetworkReply::AuthenticationRequiredError ||
1334         error == QNetworkReply::ContentReSendError ||
1335         error == QNetworkReply::UnknownContentError) {
1336         m_state = Loading;
1337         v8::TryCatch tc;
1338         dispatchCallback(m_me);
1339         if (tc.HasCaught()) printError(tc.Message());
1340     } else {
1341         m_errorFlag = true;
1342     }
1343
1344     m_state = Done;
1345
1346     v8::TryCatch tc;
1347     dispatchCallback(m_me);
1348     if (tc.HasCaught()) printError(tc.Message());
1349 }
1350
1351 #define XMLHTTPREQUEST_MAXIMUM_REDIRECT_RECURSION 15
1352 void QDeclarativeXMLHttpRequest::finished()
1353 {
1354     v8::HandleScope handle_scope;
1355
1356     m_redirectCount++;
1357     if (m_redirectCount < XMLHTTPREQUEST_MAXIMUM_REDIRECT_RECURSION) {
1358         QVariant redirect = m_network->attribute(QNetworkRequest::RedirectionTargetAttribute);
1359         if (redirect.isValid()) {
1360             QUrl url = m_network->url().resolved(redirect.toUrl());
1361             destroyNetwork();
1362             requestFromUrl(url);
1363             return;
1364         }
1365     }
1366
1367     m_status =
1368         m_network->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
1369     m_statusText =
1370         QString::fromUtf8(m_network->attribute(QNetworkRequest::HttpReasonPhraseAttribute).toByteArray());
1371
1372     if (m_state < HeadersReceived) {
1373         m_state = HeadersReceived;
1374         fillHeadersList ();
1375         v8::TryCatch tc;
1376         dispatchCallback(m_me);
1377         if (tc.HasCaught()) printError(tc.Message());
1378     }
1379     m_responseEntityBody.append(m_network->readAll());
1380     readEncoding();
1381
1382     if (xhrDump()) {
1383         qWarning().nospace() << "XMLHttpRequest: RESPONSE " << qPrintable(m_url.toString());
1384         if (!m_responseEntityBody.isEmpty()) {
1385             qWarning().nospace() << "                "
1386                                  << qPrintable(QString::fromUtf8(m_responseEntityBody));
1387         }
1388     }
1389
1390
1391     m_data.clear();
1392     destroyNetwork();
1393     if (m_state < Loading) {
1394         m_state = Loading;
1395         v8::TryCatch tc;
1396         dispatchCallback(m_me);
1397         if (tc.HasCaught()) printError(tc.Message());
1398     }
1399     m_state = Done;
1400
1401     v8::TryCatch tc;
1402     dispatchCallback(m_me);
1403     if (tc.HasCaught()) printError(tc.Message());
1404
1405     setMe(v8::Handle<v8::Object>());
1406 }
1407
1408
1409 void QDeclarativeXMLHttpRequest::readEncoding()
1410 {
1411     foreach (const HeaderPair &header, m_headersList) {
1412         if (header.first == "content-type") {
1413             int separatorIdx = header.second.indexOf(';');
1414             if (separatorIdx == -1) {
1415                 m_mime == header.second;
1416             } else {
1417                 m_mime = header.second.mid(0, separatorIdx);
1418                 int charsetIdx = header.second.indexOf("charset=");
1419                 if (charsetIdx != -1) {
1420                     charsetIdx += 8;
1421                     separatorIdx = header.second.indexOf(';', charsetIdx);
1422                     m_charset = header.second.mid(charsetIdx, separatorIdx >= 0 ? separatorIdx : header.second.length());
1423                 }
1424             }
1425             break;
1426         }
1427     }
1428
1429     if (m_mime.isEmpty() || m_mime == "text/xml" || m_mime == "application/xml" || m_mime.endsWith("+xml"))
1430         m_gotXml = true;
1431 }
1432
1433 bool QDeclarativeXMLHttpRequest::receivedXml() const
1434 {
1435     return m_gotXml;
1436 }
1437
1438
1439 #ifndef QT_NO_TEXTCODEC
1440 QTextCodec* QDeclarativeXMLHttpRequest::findTextCodec() const
1441 {
1442     QTextCodec *codec = 0;
1443
1444     if (!m_charset.isEmpty())
1445         codec = QTextCodec::codecForName(m_charset);
1446
1447     if (!codec && m_gotXml) {
1448         QXmlStreamReader reader(m_responseEntityBody);
1449         reader.readNext();
1450         codec = QTextCodec::codecForName(reader.documentEncoding().toString().toUtf8());
1451     }
1452
1453     if (!codec && m_mime == "text/html")
1454         codec = QTextCodec::codecForHtml(m_responseEntityBody, 0);
1455
1456     if (!codec)
1457         codec = QTextCodec::codecForUtfText(m_responseEntityBody, 0);
1458
1459     if (!codec)
1460         codec = QTextCodec::codecForName("UTF-8");
1461     return codec;
1462 }
1463 #endif
1464
1465
1466 QString QDeclarativeXMLHttpRequest::responseBody()
1467 {
1468 #ifndef QT_NO_TEXTCODEC
1469     if (!m_textCodec)
1470         m_textCodec = findTextCodec();
1471     if (m_textCodec)
1472         return m_textCodec->toUnicode(m_responseEntityBody);
1473 #endif
1474
1475     return QString::fromUtf8(m_responseEntityBody);
1476 }
1477
1478 const QByteArray &QDeclarativeXMLHttpRequest::rawResponseBody() const
1479 {
1480     return m_responseEntityBody;
1481 }
1482
1483 // Requires a TryCatch scope
1484 void QDeclarativeXMLHttpRequest::dispatchCallback(v8::Handle<v8::Object> me)
1485 {
1486     v8::Local<v8::Value> callback = me->Get(v8::String::New("onreadystatechange"));
1487     if (callback->IsFunction()) {
1488         v8::Local<v8::Function> f = v8::Local<v8::Function>::Cast(callback);
1489
1490         f->Call(me, 0, 0);
1491     }
1492 }
1493
1494 // Must have a handle scope
1495 void QDeclarativeXMLHttpRequest::printError(v8::Handle<v8::Message> message)
1496 {
1497     v8::Context::Scope scope(engine->context());
1498
1499     QDeclarativeError error;
1500     QDeclarativeExpressionPrivate::exceptionToError(message, error);
1501     QDeclarativeEnginePrivate::warning(QDeclarativeEnginePrivate::get(engine->engine()), error);
1502 }
1503
1504 void QDeclarativeXMLHttpRequest::destroyNetwork()
1505 {
1506     if (m_network) {
1507         m_network->disconnect();
1508         m_network->deleteLater();
1509         m_network = 0;
1510     }
1511 }
1512
1513 // XMLHttpRequest methods
1514 static v8::Handle<v8::Value> qmlxmlhttprequest_open(const v8::Arguments &args)
1515 {
1516     QDeclarativeXMLHttpRequest *r = v8_resource_cast<QDeclarativeXMLHttpRequest>(args.This());
1517     if (!r)
1518         V8THROW_REFERENCE("Not an XMLHttpRequest object");
1519
1520     if (args.Length() < 2 || args.Length() > 5)
1521         V8THROW_DOM(SYNTAX_ERR, "Incorrect argument count");
1522
1523     QV8Engine *engine = r->engine;
1524
1525     // Argument 0 - Method
1526     QString method = engine->toString(args[0]).toUpper();
1527     if (method != QLatin1String("GET") &&
1528         method != QLatin1String("PUT") &&
1529         method != QLatin1String("HEAD") &&
1530         method != QLatin1String("POST") &&
1531         method != QLatin1String("DELETE"))
1532         V8THROW_DOM(SYNTAX_ERR, "Unsupported HTTP method type");
1533
1534     // Argument 1 - URL
1535     QUrl url = QUrl::fromEncoded(engine->toString(args[1]).toUtf8());
1536
1537     if (url.isRelative())
1538         url = engine->callingContext()->resolvedUrl(url);
1539
1540     // Argument 2 - async (optional)
1541     if (args.Length() > 2 && !args[2]->BooleanValue())
1542         V8THROW_DOM(NOT_SUPPORTED_ERR, "Synchronous XMLHttpRequest calls are not supported");
1543
1544     // Argument 3/4 - user/pass (optional)
1545     QString username, password;
1546     if (args.Length() > 3)
1547         username = engine->toString(args[3]);
1548     if (args.Length() > 4)
1549         password = engine->toString(args[4]);
1550
1551     // Clear the fragment (if any)
1552     url.setFragment(QString());
1553
1554     // Set username/password
1555     if (!username.isNull()) url.setUserName(username);
1556     if (!password.isNull()) url.setPassword(password);
1557
1558     return r->open(args.This(), method, url);
1559 }
1560
1561 static v8::Handle<v8::Value> qmlxmlhttprequest_setRequestHeader(const v8::Arguments &args)
1562 {
1563     QDeclarativeXMLHttpRequest *r = v8_resource_cast<QDeclarativeXMLHttpRequest>(args.This());
1564     if (!r)
1565         V8THROW_REFERENCE("Not an XMLHttpRequest object");
1566
1567     if (args.Length() != 2)
1568         V8THROW_DOM(SYNTAX_ERR, "Incorrect argument count");
1569
1570     if (r->readyState() != QDeclarativeXMLHttpRequest::Opened || r->sendFlag())
1571         V8THROW_DOM(INVALID_STATE_ERR, "Invalid state");
1572
1573     QV8Engine *engine = r->engine;
1574
1575     QString name = engine->toString(args[0]);
1576     QString value = engine->toString(args[1]);
1577
1578     // ### Check that name and value are well formed
1579
1580     QString nameUpper = name.toUpper();
1581     if (nameUpper == QLatin1String("ACCEPT-CHARSET") ||
1582         nameUpper == QLatin1String("ACCEPT-ENCODING") ||
1583         nameUpper == QLatin1String("CONNECTION") ||
1584         nameUpper == QLatin1String("CONTENT-LENGTH") ||
1585         nameUpper == QLatin1String("COOKIE") ||
1586         nameUpper == QLatin1String("COOKIE2") ||
1587         nameUpper == QLatin1String("CONTENT-TRANSFER-ENCODING") ||
1588         nameUpper == QLatin1String("DATE") ||
1589         nameUpper == QLatin1String("EXPECT") ||
1590         nameUpper == QLatin1String("HOST") ||
1591         nameUpper == QLatin1String("KEEP-ALIVE") ||
1592         nameUpper == QLatin1String("REFERER") ||
1593         nameUpper == QLatin1String("TE") ||
1594         nameUpper == QLatin1String("TRAILER") ||
1595         nameUpper == QLatin1String("TRANSFER-ENCODING") ||
1596         nameUpper == QLatin1String("UPGRADE") ||
1597         nameUpper == QLatin1String("USER-AGENT") ||
1598         nameUpper == QLatin1String("VIA") ||
1599         nameUpper.startsWith(QLatin1String("PROXY-")) ||
1600         nameUpper.startsWith(QLatin1String("SEC-")))
1601         return v8::Undefined();
1602
1603     r->addHeader(name, value);
1604
1605     return v8::Undefined();
1606 }
1607
1608 static v8::Handle<v8::Value> qmlxmlhttprequest_send(const v8::Arguments &args)
1609 {
1610     QDeclarativeXMLHttpRequest *r = v8_resource_cast<QDeclarativeXMLHttpRequest>(args.This());
1611     if (!r)
1612         V8THROW_REFERENCE("Not an XMLHttpRequest object");
1613
1614     QV8Engine *engine = r->engine;
1615
1616     if (r->readyState() != QDeclarativeXMLHttpRequest::Opened ||
1617         r->sendFlag())
1618         V8THROW_DOM(INVALID_STATE_ERR, "Invalid state");
1619
1620     QByteArray data;
1621     if (args.Length() > 0)
1622         data = engine->toString(args[0]).toUtf8();
1623
1624     return r->send(args.This(), data);
1625 }
1626
1627 static v8::Handle<v8::Value> qmlxmlhttprequest_abort(const v8::Arguments &args)
1628 {
1629     QDeclarativeXMLHttpRequest *r = v8_resource_cast<QDeclarativeXMLHttpRequest>(args.This());
1630     if (!r)
1631         V8THROW_REFERENCE("Not an XMLHttpRequest object");
1632
1633     return r->abort(args.This());
1634 }
1635
1636 static v8::Handle<v8::Value> qmlxmlhttprequest_getResponseHeader(const v8::Arguments &args)
1637 {
1638     QDeclarativeXMLHttpRequest *r = v8_resource_cast<QDeclarativeXMLHttpRequest>(args.This());
1639     if (!r)
1640         V8THROW_REFERENCE("Not an XMLHttpRequest object");
1641
1642     QV8Engine *engine = r->engine;
1643
1644     if (args.Length() != 1)
1645         V8THROW_DOM(SYNTAX_ERR, "Incorrect argument count");
1646
1647     if (r->readyState() != QDeclarativeXMLHttpRequest::Loading &&
1648         r->readyState() != QDeclarativeXMLHttpRequest::Done &&
1649         r->readyState() != QDeclarativeXMLHttpRequest::HeadersReceived)
1650         V8THROW_DOM(INVALID_STATE_ERR, "Invalid state");
1651
1652     return engine->toString(r->header(engine->toString(args[0])));
1653 }
1654
1655 static v8::Handle<v8::Value> qmlxmlhttprequest_getAllResponseHeaders(const v8::Arguments &args)
1656 {
1657     QDeclarativeXMLHttpRequest *r = v8_resource_cast<QDeclarativeXMLHttpRequest>(args.This());
1658     if (!r)
1659         V8THROW_REFERENCE("Not an XMLHttpRequest object");
1660
1661     QV8Engine *engine = r->engine;
1662
1663     if (args.Length() != 0)
1664         V8THROW_DOM(SYNTAX_ERR, "Incorrect argument count");
1665
1666     if (r->readyState() != QDeclarativeXMLHttpRequest::Loading &&
1667         r->readyState() != QDeclarativeXMLHttpRequest::Done &&
1668         r->readyState() != QDeclarativeXMLHttpRequest::HeadersReceived)
1669         V8THROW_DOM(INVALID_STATE_ERR, "Invalid state");
1670
1671     return engine->toString(r->headers());
1672 }
1673
1674 // XMLHttpRequest properties
1675 static v8::Handle<v8::Value> qmlxmlhttprequest_readyState(v8::Local<v8::String> property,
1676                                                           const v8::AccessorInfo& info)
1677 {
1678     QDeclarativeXMLHttpRequest *r = v8_resource_cast<QDeclarativeXMLHttpRequest>(info.This());
1679     if (!r)
1680         V8THROW_REFERENCE("Not an XMLHttpRequest object");
1681
1682     return v8::Integer::NewFromUnsigned(r->readyState());
1683 }
1684
1685 static v8::Handle<v8::Value> qmlxmlhttprequest_status(v8::Local<v8::String> property,
1686                                                       const v8::AccessorInfo& info)
1687 {
1688     QDeclarativeXMLHttpRequest *r = v8_resource_cast<QDeclarativeXMLHttpRequest>(info.This());
1689     if (!r)
1690         V8THROW_REFERENCE("Not an XMLHttpRequest object");
1691
1692     if (r->readyState() == QDeclarativeXMLHttpRequest::Unsent ||
1693         r->readyState() == QDeclarativeXMLHttpRequest::Opened)
1694         V8THROW_DOM(INVALID_STATE_ERR, "Invalid state");
1695
1696     if (r->errorFlag())
1697         return v8::Integer::New(0);
1698     else
1699         return v8::Integer::New(r->replyStatus());
1700 }
1701
1702 static v8::Handle<v8::Value> qmlxmlhttprequest_statusText(v8::Local<v8::String> property,
1703                                                           const v8::AccessorInfo& info)
1704 {
1705     QDeclarativeXMLHttpRequest *r = v8_resource_cast<QDeclarativeXMLHttpRequest>(info.This());
1706     if (!r)
1707         V8THROW_REFERENCE("Not an XMLHttpRequest object");
1708
1709     QV8Engine *engine = r->engine;
1710
1711     if (r->readyState() == QDeclarativeXMLHttpRequest::Unsent ||
1712         r->readyState() == QDeclarativeXMLHttpRequest::Opened)
1713         V8THROW_DOM(INVALID_STATE_ERR, "Invalid state");
1714
1715     if (r->errorFlag())
1716         return engine->toString(QString());
1717     else
1718         return engine->toString(r->replyStatusText());
1719 }
1720
1721 static v8::Handle<v8::Value> qmlxmlhttprequest_responseText(v8::Local<v8::String> property,
1722                                                             const v8::AccessorInfo& info)
1723 {
1724     QDeclarativeXMLHttpRequest *r = v8_resource_cast<QDeclarativeXMLHttpRequest>(info.This());
1725     if (!r)
1726         V8THROW_REFERENCE("Not an XMLHttpRequest object");
1727
1728     QV8Engine *engine = r->engine;
1729
1730     if (r->readyState() != QDeclarativeXMLHttpRequest::Loading &&
1731         r->readyState() != QDeclarativeXMLHttpRequest::Done)
1732         return engine->toString(QString());
1733     else
1734         return engine->toString(r->responseBody());
1735 }
1736
1737 static v8::Handle<v8::Value> qmlxmlhttprequest_responseXML(v8::Local<v8::String> property,
1738                                                             const v8::AccessorInfo& info)
1739 {
1740     QDeclarativeXMLHttpRequest *r = v8_resource_cast<QDeclarativeXMLHttpRequest>(info.This());
1741     if (!r)
1742         V8THROW_REFERENCE("Not an XMLHttpRequest object");
1743
1744     if (!r->receivedXml() ||
1745         (r->readyState() != QDeclarativeXMLHttpRequest::Loading &&
1746          r->readyState() != QDeclarativeXMLHttpRequest::Done)) {
1747         return v8::Null();
1748     } else {
1749         return Document::load(r->engine, r->rawResponseBody());
1750     }
1751 }
1752
1753 static v8::Handle<v8::Value> qmlxmlhttprequest_new(const v8::Arguments &args)
1754 {
1755     if (args.IsConstructCall()) {
1756         QV8Engine *engine = V8ENGINE();
1757         QDeclarativeEnginePrivate *ep = QDeclarativeEnginePrivate::get(engine->engine());
1758
1759         QDeclarativeXMLHttpRequest *r = new QDeclarativeXMLHttpRequest(engine, engine->networkAccessManager());
1760         args.This()->SetExternalResource(r);
1761
1762         return args.This();
1763     } else {
1764         return v8::Undefined();
1765     }
1766 }
1767
1768 #define NEWFUNCTION(function) v8::FunctionTemplate::New(function)->GetFunction()
1769
1770 void qt_rem_qmlxmlhttprequest(QV8Engine *engine, void *d)
1771 {
1772     QDeclarativeXMLHttpRequestData *data = (QDeclarativeXMLHttpRequestData *)d;
1773     delete data;
1774 }
1775
1776 void *qt_add_qmlxmlhttprequest(QV8Engine *engine)
1777 {
1778     v8::PropertyAttribute attributes = (v8::PropertyAttribute)(v8::ReadOnly | v8::DontEnum | v8::DontDelete);
1779
1780     // XMLHttpRequest
1781     v8::Local<v8::FunctionTemplate> xmlhttprequest = v8::FunctionTemplate::New(qmlxmlhttprequest_new,
1782                                                                                v8::External::Wrap(engine));
1783     xmlhttprequest->InstanceTemplate()->SetHasExternalResource(true);
1784
1785     // Methods
1786     xmlhttprequest->PrototypeTemplate()->Set(v8::String::New("open"), NEWFUNCTION(qmlxmlhttprequest_open), attributes);
1787     xmlhttprequest->PrototypeTemplate()->Set(v8::String::New("setRequestHeader"), NEWFUNCTION(qmlxmlhttprequest_setRequestHeader), attributes);
1788     xmlhttprequest->PrototypeTemplate()->Set(v8::String::New("send"), NEWFUNCTION(qmlxmlhttprequest_send), attributes);
1789     xmlhttprequest->PrototypeTemplate()->Set(v8::String::New("abort"), NEWFUNCTION(qmlxmlhttprequest_abort), attributes);
1790     xmlhttprequest->PrototypeTemplate()->Set(v8::String::New("getResponseHeader"), NEWFUNCTION(qmlxmlhttprequest_getResponseHeader), attributes);
1791     xmlhttprequest->PrototypeTemplate()->Set(v8::String::New("getAllResponseHeaders"), NEWFUNCTION(qmlxmlhttprequest_getAllResponseHeaders), attributes);
1792
1793     // Read-only properties
1794     xmlhttprequest->PrototypeTemplate()->SetAccessor(v8::String::New("readyState"), qmlxmlhttprequest_readyState, 0, v8::Handle<v8::Value>(), v8::DEFAULT, attributes);
1795     xmlhttprequest->PrototypeTemplate()->SetAccessor(v8::String::New("status"),qmlxmlhttprequest_status, 0, v8::Handle<v8::Value>(), v8::DEFAULT, attributes);
1796     xmlhttprequest->PrototypeTemplate()->SetAccessor(v8::String::New("statusText"),qmlxmlhttprequest_statusText, 0, v8::Handle<v8::Value>(), v8::DEFAULT, attributes);
1797     xmlhttprequest->PrototypeTemplate()->SetAccessor(v8::String::New("responseText"),qmlxmlhttprequest_responseText, 0, v8::Handle<v8::Value>(), v8::DEFAULT, attributes);
1798     xmlhttprequest->PrototypeTemplate()->SetAccessor(v8::String::New("responseXML"),qmlxmlhttprequest_responseXML, 0, v8::Handle<v8::Value>(), v8::DEFAULT, attributes);
1799
1800     // State values
1801     xmlhttprequest->PrototypeTemplate()->Set(v8::String::New("UNSENT"), v8::Integer::New(0), attributes);
1802     xmlhttprequest->PrototypeTemplate()->Set(v8::String::New("OPENED"), v8::Integer::New(1), attributes);
1803     xmlhttprequest->PrototypeTemplate()->Set(v8::String::New("HEADERS_RECEIVED"), v8::Integer::New(2), attributes);
1804     xmlhttprequest->PrototypeTemplate()->Set(v8::String::New("LOADING"), v8::Integer::New(3), attributes);
1805     xmlhttprequest->PrototypeTemplate()->Set(v8::String::New("DONE"), v8::Integer::New(4), attributes);
1806
1807     // Constructor
1808     xmlhttprequest->Set(v8::String::New("UNSENT"), v8::Integer::New(0), attributes);
1809     xmlhttprequest->Set(v8::String::New("OPENED"), v8::Integer::New(1), attributes);
1810     xmlhttprequest->Set(v8::String::New("HEADERS_RECEIVED"), v8::Integer::New(2), attributes);
1811     xmlhttprequest->Set(v8::String::New("LOADING"), v8::Integer::New(3), attributes);
1812     xmlhttprequest->Set(v8::String::New("DONE"), v8::Integer::New(4), attributes);
1813     engine->global()->Set(v8::String::New("XMLHttpRequest"), xmlhttprequest->GetFunction());
1814
1815     // DOM Exception
1816     v8::Local<v8::Object> domexception = v8::Object::New();
1817     domexception->Set(v8::String::New("INDEX_SIZE_ERR"), v8::Integer::New(INDEX_SIZE_ERR), attributes);
1818     domexception->Set(v8::String::New("DOMSTRING_SIZE_ERR"), v8::Integer::New(DOMSTRING_SIZE_ERR), attributes);
1819     domexception->Set(v8::String::New("HIERARCHY_REQUEST_ERR"), v8::Integer::New(HIERARCHY_REQUEST_ERR), attributes);
1820     domexception->Set(v8::String::New("WRONG_DOCUMENT_ERR"), v8::Integer::New(WRONG_DOCUMENT_ERR), attributes);
1821     domexception->Set(v8::String::New("INVALID_CHARACTER_ERR"), v8::Integer::New(INVALID_CHARACTER_ERR), attributes);
1822     domexception->Set(v8::String::New("NO_DATA_ALLOWED_ERR"), v8::Integer::New(NO_DATA_ALLOWED_ERR), attributes);
1823     domexception->Set(v8::String::New("NO_MODIFICATION_ALLOWED_ERR"), v8::Integer::New(NO_MODIFICATION_ALLOWED_ERR), attributes);
1824     domexception->Set(v8::String::New("NOT_FOUND_ERR"), v8::Integer::New(NOT_FOUND_ERR), attributes);
1825     domexception->Set(v8::String::New("NOT_SUPPORTED_ERR"), v8::Integer::New(NOT_SUPPORTED_ERR), attributes);
1826     domexception->Set(v8::String::New("INUSE_ATTRIBUTE_ERR"), v8::Integer::New(INUSE_ATTRIBUTE_ERR), attributes);
1827     domexception->Set(v8::String::New("INVALID_STATE_ERR"), v8::Integer::New(INVALID_STATE_ERR), attributes);
1828     domexception->Set(v8::String::New("SYNTAX_ERR"), v8::Integer::New(SYNTAX_ERR), attributes);
1829     domexception->Set(v8::String::New("INVALID_MODIFICATION_ERR"), v8::Integer::New(INVALID_MODIFICATION_ERR), attributes);
1830     domexception->Set(v8::String::New("NAMESPACE_ERR"), v8::Integer::New(NAMESPACE_ERR), attributes);
1831     domexception->Set(v8::String::New("INVALID_ACCESS_ERR"), v8::Integer::New(INVALID_ACCESS_ERR), attributes);
1832     domexception->Set(v8::String::New("VALIDATION_ERR"), v8::Integer::New(VALIDATION_ERR), attributes);
1833     domexception->Set(v8::String::New("TYPE_MISMATCH_ERR"), v8::Integer::New(TYPE_MISMATCH_ERR), attributes);
1834     engine->global()->Set(v8::String::New("DOMException"), domexception);
1835
1836     QDeclarativeXMLHttpRequestData *data = new QDeclarativeXMLHttpRequestData;
1837     return data;
1838 }
1839
1840 QT_END_NAMESPACE
1841
1842 #endif // QT_NO_XMLSTREAMREADER
1843
1844 #include <qdeclarativexmlhttprequest.moc>