void FrameFetchContext::dispatchDidLoadResourceFromMemoryCache(const Resource* resource)
{
ResourceRequest request(resource->url());
unsigned long identifier = createUniqueIdentifier();
frame()->loader().client()->dispatchDidLoadResourceFromMemoryCache(request, resource->response());
dispatchWillSendRequest(identifier, request, ResourceResponse(), resource->options().initiatorInfo);
InspectorInstrumentation::markResourceAsCached(frame(), identifier);
if (!resource->response().isNull())
dispatchDidReceiveResponse(identifier, resource->response());
if (resource->encodedSize() > 0)
dispatchDidReceiveData(identifier, 0, resource->encodedSize(), 0);
dispatchDidFinishLoading(identifier, 0, 0);
}
void InspectorResourceAgent::didLoadResourceFromMemoryCache(DocumentLoader* loader, CachedResource* resource)
{
String loaderId = m_pageAgent->loaderId(loader);
String frameId = m_pageAgent->frameId(loader->frame());
unsigned long identifier = createUniqueIdentifier();
String requestId = IdentifiersFactory::requestId(identifier);
m_resourcesData->resourceCreated(requestId, loaderId);
m_resourcesData->addCachedResource(requestId, resource);
if (resource->type() == CachedResource::RawResource) {
CachedRawResource* rawResource = static_cast<CachedRawResource*>(resource);
String rawRequestId = IdentifiersFactory::requestId(rawResource->identifier());
m_resourcesData->reuseXHRReplayData(requestId, rawRequestId);
}
RefPtr<TypeBuilder::Network::Initiator> initiatorObject = buildInitiatorObject(loader->frame() ? loader->frame()->document() : 0);
m_frontend->requestServedFromMemoryCache(requestId, frameId, loaderId, loader->url().string(), currentTime(), initiatorObject, buildObjectForCachedResource(*resource, loader));
}
PingLoader::PingLoader(LocalFrame* frame, ResourceRequest& request, const FetchInitiatorInfo& initiatorInfo, StoredCredentials credentialsAllowed)
: LocalFrameLifecycleObserver(frame)
, m_timeout(this, &PingLoader::timeout)
, m_url(request.url())
, m_identifier(createUniqueIdentifier())
{
frame->loader().client()->didDispatchPingLoader(request.url());
TRACE_EVENT_INSTANT1("devtools.timeline", "ResourceSendRequest", TRACE_EVENT_SCOPE_THREAD, "data", InspectorSendRequestEvent::data(m_identifier, frame, request));
InspectorInstrumentation::willSendRequest(frame, m_identifier, frame->loader().documentLoader(), request, ResourceResponse(), initiatorInfo);
m_loader = adoptPtr(Platform::current()->createURLLoader());
ASSERT(m_loader);
WrappedResourceRequest wrappedRequest(request);
wrappedRequest.setAllowStoredCredentials(credentialsAllowed == AllowStoredCredentials);
m_loader->loadAsynchronously(wrappedRequest, this);
// If the server never responds, FrameLoader won't be able to cancel this load and
// we'll sit here waiting forever. Set a very generous timeout, just in case.
m_timeout.startOneShot(60000, BLINK_FROM_HERE);
}
AAFRESULT aafMobIDNew(
aafMobID_t *mobID) /* OUT - Newly created Mob ID */
{
#if defined(AAF_CREATE_SMPTE_UMIDS)
OMMaterialIdentification id =
{{0x06, 0x0a, 0x2b, 0x34, 0x01, 0x01, 0x01, 0x05, 0x01, 0x01, 0x0f, 0x00},
0x13, 0x00, 0x00, 0x00};
id.material = createUniqueIdentifier();
memcpy( mobID, reinterpret_cast<aafMobID_t*>(&id), sizeof(id));
return AAFRESULT_SUCCESS;
#else
aafUInt32 major, minor;
static aafUInt32 last_part2 = 0; // Get rid of this!!!
//
// Get the time in seconds since the standard root date
//
time_t now = time(0);
major = static_cast<aafUInt32>(now);
//
// Get the time since the system start-up.
//
minor = aafGetTickCount();
assert( minor != 0 && minor != (aafUInt32)-1 );
if (last_part2 >= minor)
minor = last_part2 + 1;
last_part2 = minor;
return(aafMobIDFromMajorMinor( 42, major, minor, 0x0F, mobID ));
#endif
}
PingLoader::PingLoader(LocalFrame* frame, ResourceRequest& request, const FetchInitiatorInfo& initiatorInfo, StoredCredentials credentialsAllowed)
: PageLifecycleObserver(frame->page())
, m_timeout(this, &PingLoader::timeout)
, m_url(request.url())
, m_identifier(createUniqueIdentifier())
{
frame->loader().client()->didDispatchPingLoader(request.url());
TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "ResourceSendRequest", "data", InspectorSendRequestEvent::data(m_identifier, frame, request));
TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline.stack"), "CallStack", "stack", InspectorCallStackEvent::currentCallStack());
// FIXME(361045): remove InspectorInstrumentation calls once DevTools Timeline migrates to tracing.
InspectorInstrumentation::willSendRequest(frame, m_identifier, frame->loader().documentLoader(), request, ResourceResponse(), initiatorInfo);
m_loader = adoptPtr(blink::Platform::current()->createURLLoader());
ASSERT(m_loader);
blink::WrappedResourceRequest wrappedRequest(request);
wrappedRequest.setAllowStoredCredentials(credentialsAllowed == AllowStoredCredentials);
m_loader->loadAsynchronously(wrappedRequest, this);
// If the server never responds, FrameLoader won't be able to cancel this load and
// we'll sit here waiting forever. Set a very generous timeout, just in case.
m_timeout.startOneShot(60000, FROM_HERE);
}
ResourcePtr<Resource> ResourceFetcher::requestResource(Resource::Type type, FetchRequest& request)
{
ASSERT(request.options().synchronousPolicy == RequestAsynchronously || type == Resource::Raw);
TRACE_EVENT0("blink", "ResourceFetcher::requestResource");
KURL url = request.resourceRequest().url();
WTF_LOG(ResourceLoading, "ResourceFetcher::requestResource '%s', charset '%s', priority=%d, type=%s", url.elidedString().latin1().data(), request.charset().latin1().data(), request.priority(), ResourceTypeName(type));
// If only the fragment identifiers differ, it is the same resource.
url = MemoryCache::removeFragmentIdentifierIfNeeded(url);
if (!url.isValid())
return 0;
if (!canRequest(type, url, request.options(), request.originRestriction()))
return 0;
if (LocalFrame* f = frame())
f->loaderClient()->dispatchWillRequestResource(&request);
// See if we can use an existing resource from the cache.
ResourcePtr<Resource> resource = memoryCache()->resourceForURL(url);
const RevalidationPolicy policy = determineRevalidationPolicy(type, request, resource.get());
switch (policy) {
case Reload:
memoryCache()->remove(resource.get());
// Fall through
case Load:
resource = createResourceForLoading(type, request, request.charset());
break;
case Revalidate:
resource = createResourceForRevalidation(request, resource.get());
break;
case Use:
memoryCache()->updateForAccess(resource.get());
break;
}
if (!resource)
return 0;
if (!resource->hasClients())
m_deadStatsRecorder.update(policy);
if (policy != Use)
resource->setIdentifier(createUniqueIdentifier());
ResourceLoadPriority priority = loadPriority(type, request);
if (priority != resource->resourceRequest().priority()) {
resource->mutableResourceRequest().setPriority(priority);
resource->didChangePriority(priority, 0);
}
if (resourceNeedsLoad(resource.get(), request, policy)) {
if (!shouldLoadNewResource(type)) {
if (memoryCache()->contains(resource.get()))
memoryCache()->remove(resource.get());
return 0;
}
resource->load(this, request.options());
// For asynchronous loads that immediately fail, it's sufficient to return a
// null Resource, as it indicates that something prevented the load from starting.
// If there's a network error, that failure will happen asynchronously. However, if
// a sync load receives a network error, it will have already happened by this point.
// In that case, the requester should have access to the relevant ResourceError, so
// we need to return a non-null Resource.
if (resource->errorOccurred()) {
if (memoryCache()->contains(resource.get()))
memoryCache()->remove(resource.get());
return 0;
}
}
requestLoadStarted(resource.get(), request, policy == Use ? ResourceLoadingFromCache : ResourceLoadingFromNetwork);
ASSERT(resource->url() == url.string());
m_documentResources.set(resource->url(), resource);
return resource;
}
TEST(ImageResourceTest, MultipartImage) {
ResourceFetcher* fetcher =
ResourceFetcher::create(ImageResourceTestMockFetchContext::create());
KURL testURL(ParsedURLString, "http://www.test.com/cancelTest.html");
ScopedRegisteredURL scopedRegisteredURL(testURL);
// Emulate starting a real load, but don't expect any "real"
// WebURLLoaderClient callbacks.
ImageResource* cachedImage = ImageResource::create(ResourceRequest(testURL));
cachedImage->setIdentifier(createUniqueIdentifier());
fetcher->startLoad(cachedImage);
Persistent<MockImageResourceClient> client =
new MockImageResourceClient(cachedImage);
EXPECT_EQ(Resource::Pending, cachedImage->getStatus());
// Send the multipart response. No image or data buffer is created. Note that
// the response must be routed through ResourceLoader to ensure the load is
// flagged as multipart.
ResourceResponse multipartResponse(KURL(), "multipart/x-mixed-replace", 0,
nullAtom, String());
multipartResponse.setMultipartBoundary("boundary", strlen("boundary"));
cachedImage->loader()->didReceiveResponse(
nullptr, WrappedResourceResponse(multipartResponse), nullptr);
EXPECT_FALSE(cachedImage->resourceBuffer());
EXPECT_FALSE(cachedImage->hasImage());
EXPECT_EQ(0, client->imageChangedCount());
EXPECT_FALSE(client->notifyFinishedCalled());
EXPECT_EQ("multipart/x-mixed-replace", cachedImage->response().mimeType());
const char firstPart[] =
"--boundary\n"
"Content-Type: image/svg+xml\n\n";
cachedImage->appendData(firstPart, strlen(firstPart));
// Send the response for the first real part. No image or data buffer is
// created.
EXPECT_FALSE(cachedImage->resourceBuffer());
EXPECT_FALSE(cachedImage->hasImage());
EXPECT_EQ(0, client->imageChangedCount());
EXPECT_FALSE(client->notifyFinishedCalled());
EXPECT_EQ("image/svg+xml", cachedImage->response().mimeType());
const char secondPart[] =
"<svg xmlns='http://www.w3.org/2000/svg' width='1' height='1'><rect "
"width='1' height='1' fill='green'/></svg>\n";
// The first bytes arrive. The data buffer is created, but no image is
// created.
cachedImage->appendData(secondPart, strlen(secondPart));
EXPECT_TRUE(cachedImage->resourceBuffer());
EXPECT_FALSE(cachedImage->hasImage());
EXPECT_EQ(0, client->imageChangedCount());
EXPECT_FALSE(client->notifyFinishedCalled());
// Add a client to check an assertion error doesn't happen
// (crbug.com/630983).
Persistent<MockImageResourceClient> client2 =
new MockImageResourceClient(cachedImage);
EXPECT_EQ(0, client2->imageChangedCount());
EXPECT_FALSE(client2->notifyFinishedCalled());
const char thirdPart[] = "--boundary";
cachedImage->appendData(thirdPart, strlen(thirdPart));
ASSERT_TRUE(cachedImage->resourceBuffer());
EXPECT_EQ(strlen(secondPart) - 1, cachedImage->resourceBuffer()->size());
// This part finishes. The image is created, callbacks are sent, and the data
// buffer is cleared.
cachedImage->loader()->didFinishLoading(nullptr, 0.0, 0);
EXPECT_TRUE(cachedImage->resourceBuffer());
EXPECT_FALSE(cachedImage->errorOccurred());
ASSERT_TRUE(cachedImage->hasImage());
EXPECT_FALSE(cachedImage->getImage()->isNull());
EXPECT_EQ(1, cachedImage->getImage()->width());
EXPECT_EQ(1, cachedImage->getImage()->height());
EXPECT_EQ(1, client->imageChangedCount());
EXPECT_TRUE(client->notifyFinishedCalled());
EXPECT_EQ(1, client2->imageChangedCount());
EXPECT_TRUE(client2->notifyFinishedCalled());
}
