| /* |
| * Copyright 2012 Google Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| // Author: nikhilmadan@google.com (Nikhil Madan) |
| |
| #include "net/instaweb/rewriter/public/flush_early_content_writer_filter.h" |
| |
| #include <set> |
| |
| #include "base/logging.h" |
| #include "net/instaweb/http/public/log_record.h" |
| #include "net/instaweb/rewriter/flush_early.pb.h" |
| #include "net/instaweb/rewriter/public/flush_early_info_finder.h" |
| #include "net/instaweb/rewriter/public/request_properties.h" |
| #include "net/instaweb/rewriter/public/resource_tag_scanner.h" |
| #include "net/instaweb/rewriter/public/rewrite_driver.h" |
| #include "net/instaweb/rewriter/public/rewrite_options.h" |
| #include "net/instaweb/rewriter/public/server_context.h" |
| #include "net/instaweb/rewriter/public/static_asset_manager.h" |
| #include "pagespeed/kernel/base/abstract_mutex.h" |
| #include "pagespeed/kernel/base/escaping.h" |
| #include "pagespeed/kernel/base/statistics.h" |
| #include "pagespeed/kernel/base/stl_util.h" |
| #include "pagespeed/kernel/base/string_util.h" |
| #include "pagespeed/kernel/base/writer.h" |
| #include "pagespeed/kernel/html/html_element.h" |
| #include "pagespeed/kernel/html/html_keywords.h" |
| #include "pagespeed/kernel/html/html_name.h" |
| #include "pagespeed/kernel/html/html_node.h" |
| #include "pagespeed/kernel/http/google_url.h" |
| #include "pagespeed/kernel/http/semantic_type.h" |
| #include "pagespeed/opt/logging/enums.pb.h" |
| |
| namespace net_instaweb { |
| |
| const char FlushEarlyContentWriterFilter::kPrefetchImageTagHtml[] = |
| "new Image().src=\"%s\";"; |
| const char FlushEarlyContentWriterFilter::kPrefetchScriptTagHtml[] = |
| "<script type=\"psa_prefetch\" src=\"%s\"></script>\n"; |
| const char FlushEarlyContentWriterFilter::kPrefetchLinkTagHtml[] = |
| "<link rel=\"stylesheet\" href=\"%s\"/>\n"; |
| const char FlushEarlyContentWriterFilter::kLinkRelPrefetchTagHtml[] = |
| "<link rel=\"prefetch\" href=\"%s\"/>\n"; |
| |
| const char FlushEarlyContentWriterFilter::kPrefetchStartTimeScript[] = |
| "<script type='text/javascript'>" |
| "window.mod_pagespeed_prefetch_start = Number(new Date());" |
| "window.mod_pagespeed_num_resources_prefetched = %d" |
| "</script>"; |
| |
| const char FlushEarlyContentWriterFilter::kNumResourcesFlushedEarly[] = |
| "num_resources_flushed_early"; |
| |
| const char FlushEarlyContentWriterFilter::kFlushEarlyStyleTemplate[] = |
| "<script type=\"text/psa_flush_style\" id=\"%s\">%s</script>"; |
| |
| // This JS snippet is needed to disable all the CSS link tags that are flushed |
| // early. Adding the disabled attribute directly to the link tag does not work |
| // on some browsers like Firefox. |
| const char FlushEarlyContentWriterFilter::kDisableLinkTag[] = |
| "<script type=\"text/javascript\">" |
| "var links = document.getElementsByTagName('link');" |
| "for (var i = 0; i < links.length; ++i) {" |
| " if (links[i].getAttribute('rel') == 'stylesheet') {" |
| " links[i].disabled=true;" |
| " }" |
| "}</script>"; |
| |
| struct ResourceInfo { |
| public: |
| ResourceInfo(const GoogleString& url, |
| const GoogleString& original_url, |
| int64 time_to_download, |
| bool is_pagespeed_resource, |
| bool in_head) |
| : url_(url), |
| original_url_(original_url), |
| time_to_download_(time_to_download), |
| is_pagespeed_resource_(is_pagespeed_resource), |
| in_head_(in_head) {} |
| |
| GoogleString url_; |
| GoogleString original_url_; |
| int64 time_to_download_; |
| bool is_pagespeed_resource_; |
| bool in_head_; |
| }; |
| |
| namespace { |
| |
| // Following constants are used to determine the number of additional resources |
| // that can be flushed early if origin server is slow to respond. Time taken to |
| // download any resource is calculated as |
| // (resource_size_in_bytes / kConnectionSpeedBytesPerMs). For every |
| // kMaxParallelDownload resources, extra kTtfbMs is added. kTtfbMs, kDnsTimeMs |
| // and kTimeToConnectMs is added before any resource download time is added. |
| const int kTtfbMs = 60; |
| const int kDnsTimeMs = 50; |
| const int kTimeToConnectMs = 55; |
| const int kMaxParallelDownload = 6; |
| const int kGzipMultiplier = 3; |
| const int64 kConnectionSpeedBytesPerMs = 1 * 1024 * 1024 / (8 * 1000); // 1Mbps |
| |
| inline int64 TimeToDownload(int64 size) { |
| return size / (kConnectionSpeedBytesPerMs * kGzipMultiplier); |
| } |
| |
| // Returns true if attr has a valid url (returned in gurl), false otherwise. |
| bool ExtractUrl(const HtmlElement::Attribute* attr, |
| const RewriteDriver* driver, |
| GoogleUrl* gurl, |
| GoogleString* original_url) { |
| if (attr == NULL) { |
| return false; |
| } |
| StringPiece url(attr->DecodedValueOrNull()); |
| if (url.empty()) { |
| return false; |
| } |
| gurl->Reset(driver->base_url(), url); |
| if (!gurl->IsWebValid()) { |
| return false; |
| } |
| StringVector decoded_url; |
| if (driver->DecodeUrl(*gurl, &decoded_url) && decoded_url.size() == 1) { |
| // An encoded URL. |
| *original_url = decoded_url.at(0); |
| } else { |
| // Flush early does not handle combined rewritten URLs right now. |
| // So, we should not enter this block. But, if we do, we log the rewritten |
| // URL as is. |
| *original_url = gurl->spec_c_str(); |
| } |
| return true; |
| } |
| |
| // Returns the ContentType enum value for a given semantic_type. |
| FlushEarlyResourceInfo::ContentType GetContentType( |
| semantic_type::Category category) { |
| switch (category) { |
| case semantic_type::kScript: return FlushEarlyResourceInfo::JS; |
| case semantic_type::kImage: return FlushEarlyResourceInfo::IMAGE; |
| case semantic_type::kStylesheet: return FlushEarlyResourceInfo::CSS; |
| default: return FlushEarlyResourceInfo::UNKNOWN_CONTENT_TYPE; |
| } |
| } |
| |
| } // namespace |
| |
| FlushEarlyContentWriterFilter::FlushEarlyContentWriterFilter( |
| RewriteDriver* driver) |
| : HtmlWriterFilter(driver), |
| driver_(driver), |
| num_resources_flushed_early_( |
| driver->statistics()->GetTimedVariable(kNumResourcesFlushedEarly)) { |
| Clear(); |
| } |
| |
| void FlushEarlyContentWriterFilter::StartDocument() { |
| Clear(); |
| // Note that we set a NullWriter as the writer for this driver, and directly |
| // write whatever we need to original_writer_. |
| original_writer_ = driver_->writer(); |
| set_writer(&null_writer_); |
| DCHECK(driver_->request_headers() != NULL); |
| prefetch_mechanism_ = driver_->user_agent_matcher()->GetPrefetchMechanism( |
| driver_->user_agent()); |
| current_element_ = NULL; |
| FlushEarlyInfoFinder* finder = |
| driver_->server_context()->flush_early_info_finder(); |
| if (finder != NULL && finder->IsMeaningful(driver_)) { |
| finder->UpdateFlushEarlyInfoInDriver(driver_); |
| FlushEarlyRenderInfo* flush_early_render_info = |
| driver_->flush_early_render_info(); |
| if (flush_early_render_info != NULL) { |
| if (flush_early_render_info->private_cacheable_url_size() > 0) { |
| private_cacheable_resources_.reset(new StringSet( |
| flush_early_render_info->private_cacheable_url().begin(), |
| flush_early_render_info->private_cacheable_url().end())); |
| } |
| if (flush_early_render_info->public_cacheable_url_size() > 0) { |
| public_cacheable_resources_.reset(new StringSet( |
| flush_early_render_info->public_cacheable_url().begin(), |
| flush_early_render_info->public_cacheable_url().end())); |
| } |
| } |
| } |
| FlushEarlyInfo* flush_early_info = driver_->flush_early_info(); |
| // Set max_available_time_ms_. If average_fetch_latency_ms is not present, |
| // then max_available_time_ms_ will be zero and no extra resources will be |
| // flushed. For multiple domain shards, it will be somewhat less optimal. |
| if (flush_early_info->has_average_fetch_latency_ms()) { |
| max_available_time_ms_ = flush_early_info->average_fetch_latency_ms(); |
| } |
| { |
| ScopedMutex lock(driver_->log_record()->mutex()); |
| driver_->log_record()->logging_info()->mutable_flush_early_flow_info() |
| ->set_available_time_ms(max_available_time_ms_); |
| } |
| time_consumed_ms_ = kDnsTimeMs + kTimeToConnectMs + kTtfbMs; |
| defer_javascript_enabled_ = |
| driver_->options()->Enabled(RewriteOptions::kDeferJavascript); |
| split_html_enabled_ = |
| driver_->options()->Enabled(RewriteOptions::kSplitHtml); |
| // TODO(ksimbili): Enable flush_more_resources_early_if_time_permits after |
| // tuning the RTT, bandwidth numbers for mobile. |
| flush_more_resources_early_if_time_permits_ = |
| driver_->options()->flush_more_resources_early_if_time_permits() && |
| !driver_->request_properties()->IsMobile(); |
| } |
| |
| void FlushEarlyContentWriterFilter::EndDocument() { |
| ResourceInfoList::iterator it = js_resources_info_.begin(); |
| for (; it != js_resources_info_.end(); ++it) { |
| ResourceInfo* js_resource_info = *it; |
| bool is_flushed = false; |
| if (time_consumed_ms_ + js_resource_info->time_to_download_ < |
| max_available_time_ms_) { |
| is_flushed = true; |
| FlushResources(js_resource_info->url_, |
| js_resource_info->time_to_download_, |
| js_resource_info->is_pagespeed_resource_, |
| semantic_type::kScript); |
| } |
| GoogleUrl gurl(driver_->base_url(), js_resource_info->url_); |
| FlushEarlyResourceInfo::ResourceType resource_type = |
| GetResourceType(gurl, js_resource_info->is_pagespeed_resource_); |
| RewriterApplication::Status status = is_flushed ? |
| RewriterApplication::APPLIED_OK : RewriterApplication::NOT_APPLIED; |
| driver_->log_record()->LogFlushEarlyActivity( |
| RewriteOptions::FilterId(RewriteOptions::kFlushSubresources), |
| js_resource_info->original_url_, |
| status, |
| FlushEarlyResourceInfo::JS, |
| resource_type, |
| true /* affected by bandwidth */, |
| js_resource_info->in_head_); |
| } |
| FlushDeferJavascriptEarly(); |
| |
| if (insert_close_script_) { |
| WriteToOriginalWriter("})()</script>"); |
| } |
| |
| if (!flush_early_content_.empty()) { |
| WriteToOriginalWriter(flush_early_content_); |
| } |
| |
| if (stylesheets_flushed_) { |
| WriteToOriginalWriter(kDisableLinkTag); |
| } |
| |
| if (num_resources_flushed_ > 0) { |
| num_resources_flushed_early_->IncBy(num_resources_flushed_); |
| } |
| WriteToOriginalWriter( |
| StringPrintf(kPrefetchStartTimeScript, num_resources_flushed_)); |
| Clear(); |
| } |
| |
| void FlushEarlyContentWriterFilter::FlushDeferJavascriptEarly() { |
| bool is_bandwidth_affected = false; |
| const RewriteOptions* options = driver_->options(); |
| bool should_flush_early_js_defer_script = |
| (split_html_enabled_ || defer_javascript_enabled_) && |
| driver_->request_properties()->SupportsJsDefer( |
| driver_->options()->enable_aggressive_rewriters_for_mobile()); |
| if (should_flush_early_js_defer_script) { |
| StaticAssetEnum::StaticAsset defer_js_module = |
| split_html_enabled_ ? StaticAssetEnum::BLINK_JS : |
| StaticAssetEnum::DEFER_JS; |
| StaticAssetManager* static_asset_manager = |
| driver_->server_context()->static_asset_manager(); |
| GoogleString defer_js = static_asset_manager->GetAsset( |
| defer_js_module, options); |
| int64 time_to_download = TimeToDownload(defer_js.size()); |
| is_bandwidth_affected = true; |
| GoogleString defer_js_url = static_asset_manager->GetAssetUrl( |
| defer_js_module, options); |
| FlushResources(defer_js_url, time_to_download, false, |
| semantic_type::kScript); |
| } |
| RewriterApplication::Status status = should_flush_early_js_defer_script ? |
| RewriterApplication::APPLIED_OK : RewriterApplication::NOT_APPLIED; |
| driver_->log_record()->LogFlushEarlyActivity( |
| RewriteOptions::FilterId(RewriteOptions::kFlushSubresources), |
| "", // defer-js url need not be logged. |
| status, |
| FlushEarlyResourceInfo::JS, |
| FlushEarlyResourceInfo::DEFERJS_SCRIPT, |
| is_bandwidth_affected, |
| !in_body_); |
| } |
| |
| void FlushEarlyContentWriterFilter::StartElement(HtmlElement* element) { |
| if (element->keyword() == HtmlName::kBody) { |
| in_body_ = true; |
| } |
| if (prefetch_mechanism_ == UserAgentMatcher::kPrefetchNotSupported || |
| current_element_ != NULL) { |
| // Do nothing. |
| } else if (driver_->options()->enable_flush_early_critical_css() && |
| element->keyword() == HtmlName::kStyle && |
| element->FindAttribute(HtmlName::kDataPagespeedFlushStyle) != NULL) { |
| // This style element was added by the critical css filter. Convert this |
| // into a link tag, disable the link and flush early. |
| is_flushing_critical_style_element_ = true; |
| css_output_content_.clear(); |
| } else { |
| // There will only ever be at most one size attribute and one resource here, |
| // guaranteed by CollectFlushEarlyContentFilter. |
| HtmlElement::Attribute* size_attr = |
| element->FindAttribute(HtmlName::kDataPagespeedSize); |
| int64 size = 0; |
| if (size_attr != NULL) { |
| const char* size_attr_value = size_attr->DecodedValueOrNull(); |
| if (size_attr_value != NULL) { |
| if (!StringToInt64(size_attr_value, &size)) { |
| size = 0; |
| } |
| } |
| } |
| |
| resource_tag_scanner::UrlCategoryVector attributes; |
| resource_tag_scanner::ScanElement(element, driver_->options(), &attributes); |
| if (!attributes.empty()) { |
| DCHECK_EQ(1U, attributes.size()); |
| HtmlElement::Attribute* resource_url = attributes[0].url; |
| semantic_type::Category category = attributes[0].category; |
| if (category == semantic_type::kScript && |
| (defer_javascript_enabled_ || split_html_enabled_ || in_body_)) { |
| // Don't flush javascript resources if defer_javascript is enabled or |
| // split HTML filters are enabled. |
| // TODO(nikhilmadan): Check if the User-Agent supports defer_javascript. |
| GoogleUrl gurl; |
| GoogleString original_url; |
| if (flush_more_resources_early_if_time_permits_ && |
| ExtractUrl(resource_url, driver_, &gurl, &original_url)) { |
| bool is_pagespeed_resource = |
| driver_->server_context()->IsPagespeedResource(gurl); |
| // Scripts can be flushed for kPrefetchLinkScriptTag prefetch |
| // mechanism only if defer_javascript is disabled and |
| // flush_more_resources_in_ie_and_firefox is enabled. |
| bool can_flush_js_for_prefetch_link_script_tag = |
| prefetch_mechanism_ == |
| UserAgentMatcher::kPrefetchLinkScriptTag && |
| driver_->options()->flush_more_resources_in_ie_and_firefox() && |
| !(defer_javascript_enabled_ || split_html_enabled_); |
| FlushEarlyResourceInfo::ResourceType resource_type = |
| GetResourceType(gurl, is_pagespeed_resource); |
| if ((prefetch_mechanism_ == UserAgentMatcher::kPrefetchImageTag || |
| prefetch_mechanism_ == |
| UserAgentMatcher::kPrefetchLinkRelPrefetchTag || |
| can_flush_js_for_prefetch_link_script_tag) && |
| IsFlushable(gurl, resource_type) && size > 0) { |
| // TODO(pulkitg): Add size of private resources also. |
| // TODO(pulkitg): Add a mechanism to flush javascript if |
| // defer_javascript is enabled and prefetch mechanism is |
| // kPrefetchLinkScriptTag. |
| int64 time_to_download = TimeToDownload(size); |
| ResourceInfo* js_info = new ResourceInfo( |
| resource_url->DecodedValueOrNull(), original_url, |
| time_to_download, is_pagespeed_resource, !in_body_); |
| js_resources_info_.push_back(js_info); |
| } else { |
| driver_->log_record()->LogFlushEarlyActivity( |
| RewriteOptions::FilterId(RewriteOptions::kFlushSubresources), |
| original_url, |
| RewriterApplication::NOT_APPLIED, |
| FlushEarlyResourceInfo::JS, |
| resource_type, |
| false /* not affected by bandwidth */, |
| !in_body_); |
| } |
| } |
| } else if (category == semantic_type::kPrefetch) { |
| // Flush the element as such if category is kPrefetch. |
| current_element_ = element; |
| HtmlWriterFilter::TerminateLazyCloseElement(); |
| set_writer(original_writer_); |
| if (insert_close_script_) { |
| WriteToOriginalWriter("})()</script>"); |
| insert_close_script_ = false; |
| } |
| } else { |
| GoogleUrl gurl; |
| GoogleString original_url; |
| if (ExtractUrl(resource_url, driver_, &gurl, &original_url)) { |
| bool call_flush_resources = true; |
| int64 time_to_download = 0; |
| bool is_bandwidth_affected = false; |
| bool is_flushed = false; |
| if (category == semantic_type::kImage) { |
| time_to_download = size / kConnectionSpeedBytesPerMs; |
| bool is_prefetch_mechanism_ok = |
| (prefetch_mechanism_ == UserAgentMatcher::kPrefetchImageTag || |
| prefetch_mechanism_ == |
| UserAgentMatcher::kPrefetchLinkRelPrefetchTag || |
| prefetch_mechanism_ == |
| UserAgentMatcher::kPrefetchLinkScriptTag); |
| bool is_bandwidth_available = (size > 0) && |
| (max_available_time_ms_ > time_consumed_ms_ + time_to_download); |
| call_flush_resources = is_prefetch_mechanism_ok && |
| is_bandwidth_available; |
| is_bandwidth_affected = is_prefetch_mechanism_ok; |
| } else { |
| time_to_download = |
| size / (kConnectionSpeedBytesPerMs * kGzipMultiplier); |
| } |
| bool is_pagespeed_resource = |
| driver_->server_context()->IsPagespeedResource(gurl); |
| FlushEarlyResourceInfo::ResourceType resource_type = |
| GetResourceType(gurl, is_pagespeed_resource); |
| if (call_flush_resources && |
| IsFlushable(gurl, resource_type)) { |
| StringPiece url(resource_url->DecodedValueOrNull()); |
| FlushResources(url, time_to_download, is_pagespeed_resource, |
| category); |
| is_flushed = true; |
| } |
| RewriterApplication::Status status = is_flushed ? |
| RewriterApplication::APPLIED_OK : |
| RewriterApplication::NOT_APPLIED; |
| driver_->log_record()->LogFlushEarlyActivity( |
| RewriteOptions::FilterId(RewriteOptions::kFlushSubresources), |
| original_url, |
| status, |
| GetContentType(category), |
| resource_type, |
| is_bandwidth_affected, |
| !in_body_); |
| } |
| } |
| } |
| } |
| HtmlWriterFilter::StartElement(element); |
| } |
| |
| void FlushEarlyContentWriterFilter::Characters( |
| HtmlCharactersNode* characters_node) { |
| if (is_flushing_critical_style_element_) { |
| // TODO(mpalem): Do we need to escape this content? |
| css_output_content_ = characters_node->contents(); |
| } |
| } |
| |
| void FlushEarlyContentWriterFilter::EndElement(HtmlElement* element) { |
| HtmlWriterFilter::EndElement(element); |
| if (is_flushing_critical_style_element_) { |
| // Create a new link tag disabled element and flush it. |
| const GoogleString style_id = |
| element->AttributeValue(HtmlName::kDataPagespeedFlushStyle); |
| GoogleString css_output = ComputeFlushEarlyCriticalCss(style_id); |
| int64 size = css_output.size(); |
| StrAppend(&flush_early_content_, css_output); |
| is_flushing_critical_style_element_ = false; |
| css_output_content_.clear(); |
| |
| int64 time_to_download = TimeToDownload(size); |
| UpdateStats(time_to_download, false); |
| } |
| if (current_element_ == element) { |
| current_element_ = NULL; |
| set_writer(&null_writer_); |
| } |
| } |
| |
| GoogleString FlushEarlyContentWriterFilter::ComputeFlushEarlyCriticalCss( |
| const GoogleString& style_id) { |
| GoogleString css_output = StringPrintf(kFlushEarlyStyleTemplate, |
| style_id.c_str(), css_output_content_.c_str()); |
| return css_output; |
| } |
| |
| void FlushEarlyContentWriterFilter::Clear() { |
| in_body_ = false; |
| insert_close_script_ = false; |
| num_resources_flushed_ = 0; |
| prefetch_mechanism_ = UserAgentMatcher::kPrefetchNotSupported; |
| original_writer_ = NULL; |
| private_cacheable_resources_.reset(NULL); |
| public_cacheable_resources_.reset(NULL); |
| HtmlWriterFilter::Clear(); |
| time_consumed_ms_ = 0; |
| max_available_time_ms_ = 0; |
| STLDeleteElements(&js_resources_info_); |
| defer_javascript_enabled_ = false; |
| split_html_enabled_ = false; |
| is_flushing_critical_style_element_ = false; |
| css_output_content_.clear(); |
| flush_early_content_.clear(); |
| flush_more_resources_early_if_time_permits_ = false; |
| stylesheets_flushed_ = false; |
| } |
| |
| bool FlushEarlyContentWriterFilter::IsFlushable( |
| const GoogleUrl& gurl, |
| const FlushEarlyResourceInfo::ResourceType& resource_type) { |
| return resource_type == FlushEarlyResourceInfo::PAGESPEED || |
| resource_type == FlushEarlyResourceInfo::PRIVATE_CACHEABLE || |
| (resource_type == FlushEarlyResourceInfo::PUBLIC_CACHEABLE && |
| !driver_->options()->IsAllowed(gurl.spec_c_str())); |
| } |
| |
| void FlushEarlyContentWriterFilter::UpdateStats( |
| int64 time_to_download, bool is_pagespeed_resource) { |
| // Check if they are rewritten. If so, insert the appropriate code to |
| // make the browser load these resource early. |
| if (is_pagespeed_resource) { |
| driver_->increment_num_flushed_early_pagespeed_resources(); |
| // For every seventh request, there will be one extra RTT. |
| if (driver_->num_flushed_early_pagespeed_resources() % |
| kMaxParallelDownload == 0) { |
| time_consumed_ms_ += kTtfbMs; |
| } |
| } |
| time_consumed_ms_ += time_to_download; |
| |
| ++num_resources_flushed_; |
| } |
| |
| void FlushEarlyContentWriterFilter::FlushResourceAsImage(StringPiece url) { |
| if (!insert_close_script_) { |
| WriteToOriginalWriter("<script type=\"text/javascript\">" |
| "(function(){"); |
| insert_close_script_ = true; |
| } |
| GoogleString escaped; |
| EscapeToJsStringLiteral(url, false, &escaped); |
| WriteToOriginalWriter( |
| StringPrintf(kPrefetchImageTagHtml, escaped.c_str())); |
| } |
| |
| void FlushEarlyContentWriterFilter::FlushResourceWithHtmlTemplate( |
| const char* templ, StringPiece url) { |
| GoogleString esc_buf; |
| StringPiece escaped = HtmlKeywords::Escape(url, &esc_buf); |
| StrAppend(&flush_early_content_, |
| StringPrintf(templ, escaped.as_string().c_str())); |
| } |
| |
| void FlushEarlyContentWriterFilter::FlushResources( |
| StringPiece url, int64 time_to_download, |
| bool is_pagespeed_resource, semantic_type::Category category) { |
| UpdateStats(time_to_download, is_pagespeed_resource); |
| |
| // All resources using kPrefetchImageTagHtml are flushed together in a |
| // <script> tag. And this script tag is flushed before any other resource. |
| // We also always prefetch images using it (new Image) in hope of also |
| // starting decoding. |
| // TODO(morlovich): Whether that's a good idea needs practical testing; |
| // we should discuss it with Chromies to see if it causes any poor |
| // prioritization. |
| if (category == semantic_type::kImage) { |
| FlushResourceAsImage(url); |
| } else if (prefetch_mechanism_ == |
| UserAgentMatcher::kPrefetchLinkRelPrefetchTag) { |
| FlushResourceWithHtmlTemplate(kLinkRelPrefetchTagHtml, url); |
| } else if (category == semantic_type::kStylesheet) { |
| FlushResourceWithHtmlTemplate(kPrefetchLinkTagHtml, url); |
| stylesheets_flushed_ = true; |
| } else if (prefetch_mechanism_ == UserAgentMatcher::kPrefetchImageTag) { |
| FlushResourceAsImage(url); |
| } else if (prefetch_mechanism_ == |
| UserAgentMatcher::kPrefetchLinkScriptTag) { |
| if (category == semantic_type::kScript) { |
| FlushResourceWithHtmlTemplate(kPrefetchScriptTagHtml, url); |
| } |
| } |
| } |
| |
| void FlushEarlyContentWriterFilter::WriteToOriginalWriter( |
| const GoogleString& in) { |
| original_writer_->Write(in, driver_->message_handler()); |
| } |
| |
| FlushEarlyResourceInfo::ResourceType |
| FlushEarlyContentWriterFilter::GetResourceType(const GoogleUrl& gurl, |
| bool is_pagespeed_resource) { |
| if (is_pagespeed_resource) { |
| return FlushEarlyResourceInfo::PAGESPEED; |
| } |
| if (private_cacheable_resources_ != NULL && |
| private_cacheable_resources_->find(gurl.spec_c_str()) != |
| private_cacheable_resources_->end()) { |
| return FlushEarlyResourceInfo::PRIVATE_CACHEABLE; |
| } |
| if (public_cacheable_resources_ != NULL && |
| public_cacheable_resources_->find(gurl.spec_c_str()) != |
| public_cacheable_resources_->end()) { |
| return FlushEarlyResourceInfo::PUBLIC_CACHEABLE; |
| } |
| return FlushEarlyResourceInfo::NON_PAGESPEED; |
| } |
| |
| } // namespace net_instaweb |
