net/instaweb/rewriter/public/rewrite_driver_factory.h

Go to the documentation of this file.

/*
 * Copyright 2010 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_REWRITE_DRIVER_FACTORY_H_
#define NET_INSTAWEB_REWRITER_PUBLIC_REWRITE_DRIVER_FACTORY_H_

#include <set>
#include <vector>

#include "base/scoped_ptr.h"
#include "net/instaweb/util/public/basictypes.h"
#include "net/instaweb/util/public/function.h"
#include "net/instaweb/util/public/null_statistics.h"
#include "net/instaweb/util/public/string.h"
#include "net/instaweb/util/public/string_util.h"

namespace net_instaweb {

class AbstractClientState;
class AbstractMutex;
class BlinkCriticalLineDataFinder;
class CacheInterface;
class CriticalImagesFinder;
class FileSystem;
class FilenameEncoder;
class Hasher;
class HTTPCache;
class MessageHandler;
class NamedLockManager;
class PropertyCache;
class QueuedWorkerPool;
class ResourceManager;
class RewriteDriver;
class RewriteOptions;
class RewriteStats;
class Scheduler;
class StaticJavascriptManager;
class Statistics;
class ThreadSystem;
class Timer;
class UrlAsyncFetcher;
class UrlFetcher;
class UrlNamer;
class UsageDataReporter;
class UserAgentMatcher;

class RewriteDriverFactory {
 public:
  template<class T> class Deleter;

  enum WorkerPoolName {
    kHtmlWorkers,
    kRewriteWorkers,
    kLowPriorityRewriteWorkers,
    kNumWorkerPools
  };

  explicit RewriteDriverFactory(ThreadSystem* thread_system);

  RewriteDriverFactory();

  void InitializeDefaultOptions();

  virtual ~RewriteDriverFactory();

  void set_html_parse_message_handler(MessageHandler* message_handler);
  void set_message_handler(MessageHandler* message_handler);
  void set_file_system(FileSystem* file_system);
  void set_hasher(Hasher* hasher);
  void set_filename_encoder(FilenameEncoder* filename_encoder);
  void set_url_namer(UrlNamer* url_namer);
  void set_timer(Timer* timer);
  void set_critical_images_finder(CriticalImagesFinder* finder);
  void set_blink_critical_line_data_finder(BlinkCriticalLineDataFinder* finder);
  void set_enable_property_cache(bool enabled);
  void set_usage_data_reporter(UsageDataReporter* reporter);

  void set_slurp_directory(const StringPiece& directory);
  void set_slurp_read_only(bool read_only);
  void set_slurp_print_urls(bool read_only);

  void set_force_caching(bool u) { force_caching_ = u; }

  void set_base_url_fetcher(UrlFetcher* url_fetcher);
  void set_base_url_async_fetcher(UrlAsyncFetcher* url_fetcher);

  bool set_filename_prefix(StringPiece p);

  bool slurping_enabled() const { return !slurp_directory_.empty(); }

  MessageHandler* html_parse_message_handler();
  MessageHandler* message_handler();
  FileSystem* file_system();
  Hasher* hasher();
  FilenameEncoder* filename_encoder() { return filename_encoder_.get(); }
  UrlNamer* url_namer();
  UserAgentMatcher* user_agent_matcher();
  StaticJavascriptManager* static_javascript_manager();
  RewriteOptions* default_options() { return default_options_.get(); }

  Timer* timer();
  HTTPCache* http_cache();
  PropertyCache* page_property_cache();
  PropertyCache* client_property_cache();
  NamedLockManager* lock_manager();
  QueuedWorkerPool* WorkerPool(WorkerPoolName pool);
  Scheduler* scheduler();
  UsageDataReporter* usage_data_reporter();

  PropertyCache* MakePropertyCache(const GoogleString& cache_key_prefix,
                                   CacheInterface* cache) const;

  virtual UrlFetcher* ComputeUrlFetcher();
  virtual UrlAsyncFetcher* ComputeUrlAsyncFetcher();

  virtual HTTPCache* ComputeHTTPCache();

  ResourceManager* CreateResourceManager();

  void InitResourceManager(ResourceManager* resource_manager);

  virtual void AddPlatformSpecificRewritePasses(RewriteDriver* driver);

  virtual void AddPlatformSpecificDecodingPasses(RewriteDriver* driver);

  virtual void ApplyPlatformSpecificConfiguration(RewriteDriver* driver);

  ThreadSystem* thread_system() { return thread_system_.get(); }

  CriticalImagesFinder* critical_images_finder();
  BlinkCriticalLineDataFinder* blink_critical_line_data_finder();

  const StringSet& created_directories() const {
    return created_directories_;
  }

  bool async_rewrites() { return true; }

  RewriteStats* rewrite_stats();

  Statistics* statistics() { return statistics_; }

  static void Initialize(Statistics* statistics);
  static void Terminate();

  void SetStatistics(Statistics* stats);

  virtual void ShutDown();

  void AddCreatedDirectory(const GoogleString& dir);

  virtual RewriteOptions* NewRewriteOptions();

  virtual RewriteOptions* NewRewriteOptionsForQuery();

  const GoogleString& version_string() const { return version_string_; }
  void set_version_string(const StringPiece& version_string) {
    version_string.CopyToString(&version_string_);
  }

  void defer_delete(Function* f) { deferred_deletes_.push_back(f); }

  virtual bool IsDebugClient(const GoogleString& ip) const {
    return false;
  }

  virtual AbstractClientState* NewClientState();

 protected:
  bool FetchersComputed() const;
  void StopCacheWrites();
  StringPiece filename_prefix();

  bool TerminateResourceManager(ResourceManager* rm);

  virtual UrlFetcher* DefaultUrlFetcher() = 0;
  virtual UrlAsyncFetcher* DefaultAsyncUrlFetcher() = 0;
  virtual MessageHandler* DefaultHtmlParseMessageHandler() = 0;
  virtual MessageHandler* DefaultMessageHandler() = 0;
  virtual FileSystem* DefaultFileSystem() = 0;
  virtual Timer* DefaultTimer() = 0;

  virtual Hasher* NewHasher() = 0;

  virtual CriticalImagesFinder* DefaultCriticalImagesFinder();

  virtual BlinkCriticalLineDataFinder* DefaultBlinkCriticalLineDataFinder();

  virtual CacheInterface* DefaultCacheInterface() = 0;

  virtual NamedLockManager* DefaultLockManager();

  virtual UrlNamer* DefaultUrlNamer();

  virtual UserAgentMatcher* DefaultUserAgentMatcher();
  virtual UsageDataReporter* DefaultUsageDataReporter();

  virtual QueuedWorkerPool* CreateWorkerPool(WorkerPoolName name);

  virtual int LowPriorityLoadSheddingThreshold() const;

  virtual Scheduler* CreateScheduler();

  virtual void FetcherSetupHooks();

  virtual StringPiece LockFilePrefix();

  CacheInterface* cache_backend();

  virtual CacheInterface* property_cache_backend() { return cache_backend(); }

  virtual StaticJavascriptManager* DefaultStaticJavascriptManager();

  virtual void SetupCohorts() {}

 private:
  void SetupSlurpDirectories();
  void Init(); 

  scoped_ptr<MessageHandler> html_parse_message_handler_;
  scoped_ptr<MessageHandler> message_handler_;
  scoped_ptr<FileSystem> file_system_;
  UrlFetcher* url_fetcher_;
  UrlAsyncFetcher* url_async_fetcher_;
  scoped_ptr<UrlFetcher> base_url_fetcher_;
  scoped_ptr<UrlAsyncFetcher> base_url_async_fetcher_;
  scoped_ptr<Hasher> hasher_;
  scoped_ptr<FilenameEncoder> filename_encoder_;
  scoped_ptr<UrlNamer> url_namer_;
  scoped_ptr<UserAgentMatcher> user_agent_matcher_;
  scoped_ptr<StaticJavascriptManager> static_javascript_manager_;
  scoped_ptr<Timer> timer_;
  scoped_ptr<Scheduler> scheduler_;
  scoped_ptr<UsageDataReporter> usage_data_reporter_;

  GoogleString filename_prefix_;
  GoogleString slurp_directory_;
  bool force_caching_;
  bool slurp_read_only_;
  bool slurp_print_urls_;
  bool enable_property_cache_;

  typedef std::set<ResourceManager*> ResourceManagerSet;
  ResourceManagerSet resource_managers_;
  scoped_ptr<AbstractMutex> resource_manager_mutex_;

  scoped_ptr<RewriteOptions> default_options_;

  scoped_ptr<CacheInterface> cache_backend_;
  scoped_ptr<HTTPCache> http_cache_;

  scoped_ptr<NamedLockManager> lock_manager_;

  scoped_ptr<ThreadSystem> thread_system_;
  scoped_ptr<CriticalImagesFinder> critical_images_finder_;
  scoped_ptr<BlinkCriticalLineDataFinder> blink_critical_line_data_finder_;
  scoped_ptr<PropertyCache> page_property_cache_;
  scoped_ptr<PropertyCache> client_property_cache_;

  NullStatistics null_statistics_;
  Statistics* statistics_;

  StringSet created_directories_;

  std::vector<QueuedWorkerPool*> worker_pools_;

  scoped_ptr<RewriteStats> rewrite_stats_;

  std::vector<Function*> deferred_deletes_;

  GoogleString version_string_;

  DISALLOW_COPY_AND_ASSIGN(RewriteDriverFactory);
};

template<class T> class RewriteDriverFactory::Deleter : public Function {
 public:
  explicit Deleter(T* obj) : obj_(obj) {}
  virtual void Run() { delete obj_; }
 private:
  T* obj_;
  DISALLOW_COPY_AND_ASSIGN(Deleter);
};

}  

#endif  ///< NET_INSTAWEB_REWRITER_PUBLIC_REWRITE_DRIVER_FACTORY_H_

---