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()); }