HTMLImportLoader should talk directly to mojo::NetworkService

sky/engine/core/html/imports/HTMLImportLoader.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 52 matching lines @@
 }
 
 void HTMLImportLoader::clear()
 {
     m_controller = nullptr;
     if (m_document) {
         m_document->setImportsController(0);
         m_document->cancelParsing();
         m_document.clear();
     }
+    m_fetcher.clear();
+    m_drainer.clear();
 }
 #endif
 
-void HTMLImportLoader::startLoading(const ResourcePtr<RawResource>& resource)
+void HTMLImportLoader::startLoading(const KURL& url)
 {
-    setResource(resource);
+    m_fetcher = adoptPtr(new MojoFetcher(this, url));
 }
 
-void HTMLImportLoader::responseReceived(Resource* resource, const ResourceResponse& response)
+void HTMLImportLoader::OnReceivedResponse(mojo::URLResponsePtr response)
 {
-    // Resource may already have been loaded with the import loader
-    // being added as a client later & now being notified. Fail early.
-    if (resource->loadFailedOrCanceled() || response.httpStatusCode() >= 400) {
+    if (response->error || response->status_code >= 400) {
         setState(StateError);
         return;
     }
-    setState(startWritingAndParsing(response));
+    mojo::ScopedDataPipeConsumerHandle body = response->body.Pass();
+    setState(startWritingAndParsing(response.Pass()));
+    m_drainer = adoptPtr(new DataPipeDrainer(this, body.Pass()));
 }
 
-void HTMLImportLoader::dataReceived(Resource*, const char* data, int length)
+void HTMLImportLoader::OnDataAvailable(const void* data, size_t length)
 {
     RefPtrWillBeRawPtr<DocumentWriter> protectingWriter(m_writer.get());
-    m_writer->addData(data, length);
+    m_writer->addData(static_cast<const char*>(data), length);
 }
 
-void HTMLImportLoader::notifyFinished(Resource* resource)
+void HTMLImportLoader::OnDataComplete()
 {
-    // The writer instance indicates that a part of the document can be already loaded.
-    // We don't take such a case as an error because the partially-loaded document has been visible from script at this point.
-    if (resource->loadFailedOrCanceled() && !m_writer) {
-        setState(StateError);
-        return;
-    }
-
     setState(finishWriting());
 }
 
-HTMLImportLoader::State HTMLImportLoader::startWritingAndParsing(const ResourceResponse& response)
+HTMLImportLoader::State HTMLImportLoader::startWritingAndParsing(mojo::URLResponsePtr response)
 {
     ASSERT(!m_imports.isEmpty());
-    DocumentInit init = DocumentInit(response.url(), 0, m_controller->master()->contextDocument(), m_controller)
+    KURL url(ParsedURLString, String::fromUTF8(response->url));
+    DocumentInit init = DocumentInit(url, 0, m_controller->master()->contextDocument(), m_controller)
         .withRegistrationContext(m_controller->master()->registrationContext());
     m_document = HTMLDocument::create(init);
     m_writer = DocumentWriter::create(m_document.get());
 
     return StateLoading;
 }
 
 HTMLImportLoader::State HTMLImportLoader::finishWriting()
 {
     return StateWritten;
@@ skipping 36 matching lines @@
 {
     if (m_state == StateParsed)
         setState(finishLoading());
 }
 
 void HTMLImportLoader::didFinishLoading()
 {
     for (size_t i = 0; i < m_imports.size(); ++i)
         m_imports[i]->didFinishLoading();
 
-    clearResource();
-
     ASSERT(!m_document || !m_document->parsing());
 }
 
 void HTMLImportLoader::moveToFirst(HTMLImportChild* import)
 {
     size_t position = m_imports.find(import);
     ASSERT(kNotFound != position);
     m_imports.remove(position);
     m_imports.insert(0, import);
 }
@@ skipping 31 matching lines @@
     visitor->trace(m_controller);
 #if ENABLE(OILPAN)
     visitor->trace(m_imports);
 #endif
     visitor->trace(m_document);
     visitor->trace(m_writer);
     visitor->trace(m_microtaskQueue);
 }
 
 } // namespace blink