critical_selector_finder.h

Go to the documentation of this file.

/*
 * Copyright 2013 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_SELECTOR_FINDER_H_
#define NET_INSTAWEB_REWRITER_PUBLIC_CRITICAL_SELECTOR_FINDER_H_

#include "net/instaweb/rewriter/critical_keys.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 MessageHandler;
class NonceGenerator;
class RewriteDriver;
class Statistics;
class TimedVariable;
class Timer;

struct CriticalSelectorInfo {
  StringSet critical_selectors;
  CriticalKeys proto;
};

class CriticalSelectorFinder {
 public:
  static const char kCriticalSelectorsValidCount[];
  static const char kCriticalSelectorsExpiredCount[];
  static const char kCriticalSelectorsNotFoundCount[];
  static const char kCriticalSelectorsPropertyName[];

  CriticalSelectorFinder(const PropertyCache::Cohort* cohort,
                         NonceGenerator* nonce_generator, Statistics* stats);
  virtual ~CriticalSelectorFinder();

  static void InitStats(Statistics* statistics);

  bool IsCriticalSelector(RewriteDriver* driver, const GoogleString& selector);

  const StringSet& GetCriticalSelectors(RewriteDriver* driver);

  virtual void WriteCriticalSelectorsToPropertyCache(
      const StringSet& selector_set, StringPiece nonce,
      RewriteDriver* driver);

  static void WriteCriticalSelectorsToPropertyCacheStatic(
      const StringSet& selector_set, StringPiece nonce, int support_interval,
      bool should_replace_prior_result, const PropertyCache* cache,
      const PropertyCache::Cohort* cohort, AbstractPropertyPage* page,
      MessageHandler* message_handler, Timer* timer);

  BeaconMetadata PrepareForBeaconInsertion(
      const StringSet& selector_set, RewriteDriver* driver);

  virtual int SupportInterval() const = 0;

 protected:
  virtual bool ShouldReplacePriorResult() const { return false; }


 private:
  void UpdateCriticalSelectorInfoInDriver(RewriteDriver* driver);

  const PropertyCache::Cohort* cohort_;
  NonceGenerator* nonce_generator_;

  TimedVariable* critical_selectors_valid_count_;
  TimedVariable* critical_selectors_expired_count_;
  TimedVariable* critical_selectors_not_found_count_;

  
};

class BeaconCriticalSelectorFinder : public CriticalSelectorFinder {
 public:
  BeaconCriticalSelectorFinder(const PropertyCache::Cohort* cohort,
                               NonceGenerator* nonce_generator,
                               Statistics* stats)
      : CriticalSelectorFinder(cohort, nonce_generator, stats) {}

  static void WriteCriticalSelectorsToPropertyCacheFromBeacon(
      const StringSet& selector_set, StringPiece nonce,
      const PropertyCache* cache, const PropertyCache::Cohort* cohort,
      AbstractPropertyPage* page, MessageHandler* message_handler,
      Timer* timer);

 private:
  static const int kDefaultSupportInterval = 10;

  virtual int SupportInterval() const { return kDefaultSupportInterval; }
};

}  

#endif