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)

[esprehn, 2014/10/24 21:50:12]

Why void* if we just cast to char* to use it?

[abarth-chromium, 2014/10/24 21:56:37]

The code that declares this function doesn't know what the data represents.  It
could be characters or it could be binary image data.  In this series of CLs,
I'm going to push the pipe deeper and deeper into the system until its feeding
the UTF8 decoder directly.  At that point, it makes sense to take binary data
and get UChars out of it.

 {
     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