critical_images_finder.h

Go to the documentation of this file.

/*
 * 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.
 */


#ifndef NET_INSTAWEB_REWRITER_PUBLIC_CRITICAL_IMAGES_FINDER_H_
#define NET_INSTAWEB_REWRITER_PUBLIC_CRITICAL_IMAGES_FINDER_H_

#include <map>
#include <utility>

#include "net/instaweb/rewriter/critical_images.pb.h"
#include "net/instaweb/rewriter/public/critical_finder_support_util.h"
#include "net/instaweb/util/public/property_cache.h"
#include "pagespeed/kernel/base/basictypes.h"
#include "pagespeed/kernel/base/string.h"
#include "pagespeed/kernel/base/string_util.h"

namespace net_instaweb {

class GoogleUrl;
class RenderedImages;
class RewriteDriver;
class RewriteOptions;
class Statistics;
class Variable;

typedef std::map<GoogleString, std::pair<int32, int32> >
    RenderedImageDimensionsMap;

struct CriticalImagesInfo {
  CriticalImagesInfo()
      : is_critical_image_info_present(false) {}
  StringSet html_critical_images;
  StringSet css_critical_images;
  CriticalImages proto;
  bool is_critical_image_info_present;
  RenderedImageDimensionsMap rendered_images_map;
};


class CriticalImagesFinder {
 public:
  enum Availability {
    kDisabled,   
    kNoDataYet,  
    kAvailable,  
  };
  static const char kCriticalImagesValidCount[];
  static const char kCriticalImagesExpiredCount[];
  static const char kCriticalImagesNotFoundCount[];
  static const char kCriticalImagesPropertyName[];
  static const char kRenderedImageDimensionsProperty[];

  CriticalImagesFinder(const PropertyCache::Cohort* cohort, Statistics* stats);
  virtual ~CriticalImagesFinder();

  static void InitStats(Statistics* statistics);

  virtual Availability Available(RewriteDriver* driver);

  virtual int PercentSeenForCritical() const {
    return kDefaultPercentSeenForCritical;
  }

  virtual int SupportInterval() const {
    return kDefaultImageSupportInterval;
  }

  bool IsHtmlCriticalImage(StringPiece image_url, RewriteDriver* driver);

  bool IsCssCriticalImage(StringPiece image_url, RewriteDriver* driver);

  bool GetRenderedImageDimensions(
      RewriteDriver* driver,
      const GoogleUrl& image_src_gurl,
      std::pair<int32, int32>* dimensions);

  const StringSet& GetHtmlCriticalImages(RewriteDriver* driver);
  const StringSet& GetCssCriticalImages(RewriteDriver* driver);

  StringSet* mutable_html_critical_images(RewriteDriver* driver);
  StringSet* mutable_css_critical_images(RewriteDriver* driver);

  virtual void ComputeCriticalImages(RewriteDriver* driver) = 0;

  const PropertyCache::Cohort* cohort() const { return cohort_; }

  bool UpdateCriticalImagesCacheEntryFromDriver(
      const StringSet* html_critical_images_set,
      const StringSet* css_critical_images_set,
      RewriteDriver* driver);

  static bool PopulateCriticalImagesFromPropertyValue(
      const PropertyValue* property_value, CriticalImages* critical_images);

  static bool UpdateCriticalImagesCacheEntry(
      const StringSet* html_critical_images_set,
      const StringSet* css_critical_images_set,
      const RenderedImages* rendered_images_set,
      int support_interval,
      const PropertyCache::Cohort* cohort,
      AbstractPropertyPage* page);

  virtual bool IsCriticalImageInfoPresent(RewriteDriver* driver);

  virtual RenderedImages* ExtractRenderedImageDimensionsFromCache(
      RewriteDriver* driver);

  void AddHtmlCriticalImage(const GoogleString& url,
                            RewriteDriver* driver);

  RenderedImages* JsonMapToRenderedImagesMap(const GoogleString& str,
                                             const RewriteOptions* options);

  virtual bool ShouldBeacon(RewriteDriver* driver) { return false; }

  virtual BeaconMetadata PrepareForBeaconInsertion(RewriteDriver* driver) {
    BeaconMetadata result;
    result.status = kBeaconNoNonce;
    return result;
  }

  virtual void UpdateCandidateImagesForBeaconing(const StringSet& images,
                                                 RewriteDriver* driver,
                                                 bool beaconing) {}

 protected:
  static bool UpdateAndWriteBackCriticalImagesCacheEntry(
      const StringSet* html_critical_images_set,
      const StringSet* css_critical_images_set,
      const RenderedImages* rendered_images_set,
      int support_interval,
      const PropertyCache::Cohort* cohort,
      AbstractPropertyPage* page,
      CriticalImages* critical_images);

  virtual void UpdateCriticalImagesSetInDriver(RewriteDriver* driver);

  virtual GoogleString GetKeyForUrl(StringPiece url) { return url.as_string(); }

  CriticalImagesInfo* ExtractCriticalImagesFromCache(
      RewriteDriver* driver,
      const PropertyValue* property_value);

 private:
  friend class CriticalImagesFinderTestBase;

  static bool UpdateCriticalImages(const StringSet* html_critical_images,
                                   const StringSet* css_critical_images,
                                   int support_interval,
                                   CriticalImages* critical_images);

  static const int kDefaultPercentSeenForCritical = 100;
  static const int kDefaultImageSupportInterval = 1;

  const PropertyCache::Cohort* cohort_;

  Variable* critical_images_valid_count_;
  Variable* critical_images_expired_count_;
  Variable* critical_images_not_found_count_;

  
};

}  

#endif