[Offline Pages] Adding missing image/CSS detection in FrameSerializer.

third_party/WebKit/Source/core/frame/FrameSerializer.cpp

 /*
  * Copyright (C) 2011 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 249 matching lines @@
 
 // TODO(tiger): Right now there is no support for rewriting URLs inside CSS
 // documents which leads to bugs like <https://crbug.com/251898>. Not being
 // able to rewrite URLs inside CSS documents means that resources imported from
 // url(...) statements in CSS might not work when rewriting links for the
 // "Webpage, Complete" method of saving a page. It will take some work but it
 // needs to be done if we want to continue to support non-MHTML saved pages.
 
 FrameSerializer::FrameSerializer(Deque<SerializedResource>& resources,
                                  Delegate& delegate)
-    : resources_(&resources), is_serializing_css_(false), delegate_(delegate) {}
+    : resources_(&resources),
+      is_serializing_css_(false),
+      delegate_(delegate),
+      total_image_count_(0),
+      loaded_image_count_(0),
+      total_css_count_(0),
+      loaded_css_count_(0),
+      should_collect_problem_metric_(false) {}
 
 void FrameSerializer::SerializeFrame(const LocalFrame& frame) {
   TRACE_EVENT0("page-serialization", "FrameSerializer::serializeFrame");
   DCHECK(frame.GetDocument());
   Document& document = *frame.GetDocument();
   KURL url = document.Url();
 
   // If frame is an image document, add the image and don't continue
   if (document.IsImageDocument()) {
     ImageDocument& image_document = ToImageDocument(document);
@@ skipping 11 matching lines @@
     String text =
         SerializeNodes<EditingStrategy>(accumulator, document, kIncludeNode);
 
     CString frame_html =
         document.Encoding().Encode(text, WTF::kEntitiesForUnencodables);
     resources_->push_back(SerializedResource(
         url, document.SuggestedMIMEType(),
         SharedBuffer::Create(frame_html.data(), frame_html.length())));
   }
 
+  should_collect_problem_metric_ =
+      delegate_.ShouldCollectProblemMetric() && frame.IsMainFrame();
   for (Node* node : serialized_nodes) {
     DCHECK(node);
     if (!node->IsElementNode())
       continue;
 
     Element& element = ToElement(*node);
     // We have to process in-line style as it might contain some resources
     // (typically background images).
     if (element.IsStyledElement()) {
       RetrieveResourcesForProperties(element.InlineStyle(), document);
@@ skipping 22 matching lines @@
         KURL url = document.CompleteURL(
             link_element.getAttribute(HTMLNames::hrefAttr));
         SerializeCSSStyleSheet(*sheet, url);
       }
     } else if (isHTMLStyleElement(element)) {
       HTMLStyleElement& style_element = toHTMLStyleElement(element);
       if (CSSStyleSheet* sheet = style_element.sheet())
         SerializeCSSStyleSheet(*sheet, KURL());
     }
   }
+  if (should_collect_problem_metric_) {
+    // Report detectors through UMA.
+    // We're having exact 21 buckets for percentage because we want to have 5%
+    // in each bucket to avoid potential spikes in the distribution.
+    UMA_HISTOGRAM_COUNTS_100(
+        "PageSerialization.ProblemDetection.TotalImageCount",
+        static_cast<int64_t>(total_image_count_));
+    if (total_image_count_ > 0) {
+      DCHECK_LE(loaded_image_count_, total_image_count_);
+      DEFINE_STATIC_LOCAL(
+          LinearHistogram, image_histogram,
+          ("PageSerialization.ProblemDetection.LoadedImagePercentage", 1, 100,
+           21));
+      image_histogram.Count(
+          static_cast<int64_t>(loaded_image_count_ * 100 / total_image_count_));
+    }
+
+    UMA_HISTOGRAM_COUNTS_100("PageSerialization.ProblemDetection.TotalCSSCount",
+                             static_cast<int64_t>(total_css_count_));
+    if (total_css_count_ > 0) {
+      DCHECK_LE(loaded_css_count_, total_css_count_);
+      DEFINE_STATIC_LOCAL(
+          LinearHistogram, css_histogram,
+          ("PageSerialization.ProblemDetection.LoadedCSSPercentage", 1, 100,
+           21));
+      css_histogram.Count(
+          static_cast<int64_t>(loaded_css_count_ * 100 / total_css_count_));
+    }
+    should_collect_problem_metric_ = false;
+  }
 }
 
 void FrameSerializer::SerializeCSSStyleSheet(CSSStyleSheet& style_sheet,
                                              const KURL& url) {
   // If the URL is invalid or if it is a data URL this means that this CSS is
   // defined inline, respectively in a <style> tag or in the data URL itself.
   bool is_inline_css = !url.IsValid() || url.ProtocolIsData();
   // If this CSS is not inline then it is identifiable by its URL. So just skip
   // it if it has already been analyzed before.
   if (!is_inline_css && (resource_urls_.Contains(url) ||
                          delegate_.ShouldSkipResourceWithURL(url))) {
     return;
   }
+  if (!is_inline_css)
+    resource_urls_.insert(url);
+  if (should_collect_problem_metric_ && !is_inline_css) {
+    total_css_count_++;
+    if (style_sheet.LoadCompleted())
+      loaded_css_count_++;
+  }
 
   TRACE_EVENT2("page-serialization", "FrameSerializer::serializeCSSStyleSheet",
                "type", "CSS", "url", url.ElidedString().Utf8().data());
   // Only report UMA metric if this is not a reentrant CSS serialization call.
   double css_start_time = 0;
   if (!is_serializing_css_) {
     is_serializing_css_ = true;
     css_start_time = MonotonicallyIncreasingTime();
   }
 
@@ skipping 16 matching lines @@
     }
 
     WTF::TextEncoding text_encoding(style_sheet.Contents()->Charset());
     DCHECK(text_encoding.IsValid());
     String text_string = css_text.ToString();
     CString text = text_encoding.Encode(
         text_string, WTF::kCSSEncodedEntitiesForUnencodables);
     resources_->push_back(
         SerializedResource(url, String("text/css"),
                            SharedBuffer::Create(text.data(), text.length())));
-    resource_urls_.insert(url);
   }
 
   // Sub resources need to be serialized even if the CSS definition doesn't
   // need to be.
   for (unsigned i = 0; i < style_sheet.length(); ++i)
     SerializeCSSRule(style_sheet.item(i));
 
   if (css_start_time != 0) {
     is_serializing_css_ = false;
     DEFINE_STATIC_LOCAL(CustomCountHistogram, css_histogram,
@@ skipping 62 matching lines @@
     const KURL& url) {
   if (delegate_.ShouldSkipResource(has_cache_control_no_store_header))
     return;
 
   if (!data) {
     DLOG(ERROR) << "No data for resource " << url.GetString();
     return;
   }
 
   resources_->push_back(SerializedResource(url, mime_type, std::move(data)));
-  resource_urls_.insert(url);
 }
 
 void FrameSerializer::AddImageToResources(ImageResourceContent* image,
                                           const KURL& url) {
-  if (!image || !image->HasImage() || image->ErrorOccurred() ||
-      !ShouldAddURL(url))
+  if (!ShouldAddURL(url))
     return;
+  resource_urls_.insert(url);
+  if (should_collect_problem_metric_)
+    total_image_count_++;
+  if (!image || !image->HasImage() || image->ErrorOccurred())
+    return;
+  if (should_collect_problem_metric_ && image->IsLoaded())
+    loaded_image_count_++;
 
   TRACE_EVENT2("page-serialization", "FrameSerializer::addImageToResources",
                "type", "image", "url", url.ElidedString().Utf8().data());
   double image_start_time = MonotonicallyIncreasingTime();
 
   RefPtr<const SharedBuffer> data = image->GetImage()->Data();
   AddToResources(image->GetResponse().MimeType(),
                  image->HasCacheControlNoStoreHeader()
                      ? kHasCacheControlNoStoreHeader
                      : kNoCacheControlNoStoreHeader,
                  data, url);
 
   // If we're already reporting time for CSS serialization don't report it for
   // this image to avoid reporting the same time twice.
   if (!is_serializing_css_) {
     DEFINE_STATIC_LOCAL(CustomCountHistogram, image_histogram,
                         ("PageSerialization.SerializationTime.ImageElement", 0,
                          maxSerializationTimeUmaMicroseconds, 50));
     image_histogram.Count(static_cast<int64_t>(
         (MonotonicallyIncreasingTime() - image_start_time) *
         secondsToMicroseconds));
   }
 }
 
 void FrameSerializer::AddFontToResources(FontResource* font) {
-  if (!font || !font->IsLoaded() || !font->ResourceBuffer() ||
-      !ShouldAddURL(font->Url()))
+  if (!font || !ShouldAddURL(font->Url()))
+    return;
+  resource_urls_.insert(font->Url());
+  if (!font || !font->IsLoaded() || !font->ResourceBuffer())
     return;
 
   RefPtr<const SharedBuffer> data(font->ResourceBuffer());
 
   AddToResources(font->GetResponse().MimeType(),
                  font->HasCacheControlNoStoreHeader()
                      ? kHasCacheControlNoStoreHeader
                      : kNoCacheControlNoStoreHeader,
                  data, font->Url());
 }
@@ skipping 58 matching lines @@
     emits_minus = ch == '-';
     builder.Append(ch);
   }
   CString escaped_url = builder.ToString().Ascii();
   return String::Format("saved from url=(%04d)%s",
                         static_cast<int>(escaped_url.length()),
                         escaped_url.data());
 }
 
 }  // namespace blink