Page Speed Optimization Libraries
1.7.30.4
|
00001 /* 00002 * Copyright 2010 Google Inc. 00003 * 00004 * Licensed under the Apache License, Version 2.0 (the "License"); 00005 * you may not use this file except in compliance with the License. 00006 * You may obtain a copy of the License at 00007 * 00008 * http:///www.apache.org/licenses/LICENSE-2.0 00009 * 00010 * Unless required by applicable law or agreed to in writing, software 00011 * distributed under the License is distributed on an "AS IS" BASIS, 00012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 00013 * See the License for the specific language governing permissions and 00014 * limitations under the License. 00015 */ 00016 00018 00019 #ifndef NET_INSTAWEB_REWRITER_PUBLIC_REWRITE_DRIVER_FACTORY_H_ 00020 #define NET_INSTAWEB_REWRITER_PUBLIC_REWRITE_DRIVER_FACTORY_H_ 00021 00022 #include <set> 00023 #include <vector> 00024 00025 #include "net/instaweb/util/public/basictypes.h" 00026 #include "net/instaweb/util/public/function.h" 00027 #include "net/instaweb/util/public/null_statistics.h" 00028 #include "net/instaweb/util/public/scoped_ptr.h" 00029 #include "net/instaweb/util/public/string.h" 00030 #include "net/instaweb/util/public/string_util.h" 00031 00032 namespace pagespeed { namespace js { struct JsTokenizerPatterns; } } 00033 00034 namespace net_instaweb { 00035 00036 class AbstractMutex; 00037 class CacheHtmlInfoFinder; 00038 class CriticalCssFinder; 00039 class CriticalImagesFinder; 00040 class CriticalLineInfoFinder; 00041 class CriticalSelectorFinder; 00042 class FileSystem; 00043 class FilenameEncoder; 00044 class FlushEarlyInfoFinder; 00045 class ExperimentMatcher; 00046 class Hasher; 00047 class MessageHandler; 00048 class NamedLockManager; 00049 class NonceGenerator; 00050 class ProcessContext; 00051 class PropertyCache; 00052 class QueuedWorkerPool; 00053 class ServerContext; 00054 class RewriteDriver; 00055 class RewriteOptions; 00056 class RewriteOptionsManager; 00057 class RewriteStats; 00058 class Scheduler; 00059 class StaticAssetManager; 00060 class Statistics; 00061 class ThreadSystem; 00062 class Timer; 00063 class UrlAsyncFetcher; 00064 class UrlNamer; 00065 class UsageDataReporter; 00066 class UserAgentMatcher; 00067 class UserAgentNormalizer; 00068 00073 class RewriteDriverFactory { 00074 public: 00076 template<class T> class Deleter; 00077 00078 enum WorkerPoolCategory { 00079 kHtmlWorkers, 00080 kRewriteWorkers, 00081 kLowPriorityRewriteWorkers, 00083 kNumWorkerPools 00084 }; 00085 00087 RewriteDriverFactory(const ProcessContext& process_context, 00088 ThreadSystem* thread_system); 00089 00094 void InitializeDefaultOptions(); 00095 00096 virtual ~RewriteDriverFactory(); 00097 00102 void set_html_parse_message_handler(MessageHandler* message_handler); 00103 void set_message_handler(MessageHandler* message_handler); 00104 void set_file_system(FileSystem* file_system); 00105 void set_hasher(Hasher* hasher); 00106 void set_filename_encoder(FilenameEncoder* filename_encoder); 00107 void set_nonce_generator(NonceGenerator* nonce_generator); 00108 void set_url_namer(UrlNamer* url_namer); 00109 void set_timer(Timer* timer); 00110 void set_usage_data_reporter(UsageDataReporter* reporter); 00111 00121 void set_slurp_directory(const StringPiece& directory); 00122 void set_slurp_read_only(bool read_only); 00123 void set_slurp_print_urls(bool read_only); 00124 00127 void set_force_caching(bool u) { force_caching_ = u; } 00128 00137 void set_base_url_async_fetcher(UrlAsyncFetcher* url_fetcher); 00139 void set_base_distributed_async_fetcher(UrlAsyncFetcher* distributed_fetcher); 00140 bool set_filename_prefix(StringPiece p); 00141 00143 bool slurping_enabled() const { return !slurp_directory_.empty(); } 00144 00145 MessageHandler* html_parse_message_handler(); 00146 MessageHandler* message_handler(); 00147 FileSystem* file_system(); 00148 NonceGenerator* nonce_generator(); 00151 Hasher* hasher(); 00152 FilenameEncoder* filename_encoder() { return filename_encoder_.get(); } 00153 UrlNamer* url_namer(); 00154 UserAgentMatcher* user_agent_matcher(); 00155 StaticAssetManager* static_asset_manager(); 00156 RewriteOptions* default_options() { return default_options_.get(); } 00157 virtual RewriteOptionsManager* NewRewriteOptionsManager(); 00158 00163 Timer* timer(); 00164 NamedLockManager* lock_manager(); 00165 QueuedWorkerPool* WorkerPool(WorkerPoolCategory pool); 00166 Scheduler* scheduler(); 00167 UsageDataReporter* usage_data_reporter(); 00168 const pagespeed::js::JsTokenizerPatterns* js_tokenizer_patterns() const { 00169 return js_tokenizer_patterns_; 00170 } 00171 const std::vector<const UserAgentNormalizer*>& user_agent_normalizers(); 00172 00177 virtual UrlAsyncFetcher* ComputeUrlAsyncFetcher(); 00178 virtual UrlAsyncFetcher* ComputeDistributedFetcher(); 00179 00186 ServerContext* CreateServerContext(); 00187 00191 void InitServerContext(ServerContext* server_context); 00192 00197 virtual void SetupCaches(ServerContext* server_context) = 0; 00198 00202 virtual bool UseBeaconResultsInFilters() const = 0; 00203 00207 virtual void AddPlatformSpecificRewritePasses(RewriteDriver* driver); 00208 00217 virtual void AddPlatformSpecificDecodingPasses(RewriteDriver* driver); 00218 00222 virtual void ApplyPlatformSpecificConfiguration(RewriteDriver* driver); 00223 00224 ThreadSystem* thread_system() { return thread_system_.get(); } 00225 00228 const StringSet& created_directories() const { 00229 return created_directories_; 00230 } 00231 00232 bool async_rewrites() { return true; } 00233 00238 RewriteStats* rewrite_stats(); 00239 00242 Statistics* statistics() { return statistics_; } 00243 00246 static void InitStats(Statistics* statistics); 00247 00249 static void Initialize(); 00250 static void Terminate(); 00251 00253 void SetStatistics(Statistics* stats); 00254 00258 virtual void ShutDown(); 00259 00261 void AddCreatedDirectory(const GoogleString& dir); 00262 00267 virtual RewriteOptions* NewRewriteOptions(); 00268 00272 virtual RewriteOptions* NewRewriteOptionsForQuery(); 00273 00275 const GoogleString& version_string() const { return version_string_; } 00276 void set_version_string(const StringPiece& version_string) { 00277 version_string.CopyToString(&version_string_); 00278 } 00279 00283 void defer_cleanup(Function* f) { deferred_cleanups_.push_back(f); } 00284 00287 template<class T> void TakeOwnership(T* obj) { 00288 defer_cleanup(new RewriteDriverFactory::Deleter<T>(obj)); 00289 } 00290 00292 virtual bool IsDebugClient(const GoogleString& ip) const { 00293 return false; 00294 } 00295 00298 virtual ExperimentMatcher* NewExperimentMatcher(); 00299 00301 const std::vector<int>* preferred_webp_qualities() { 00302 return &preferred_webp_qualities_; 00303 } 00304 00306 const std::vector<int>* preferred_jpeg_qualities() { 00307 return &preferred_jpeg_qualities_; 00308 } 00309 00311 bool SetPreferredWebpQualities(const StringPiece& qualities); 00312 00314 bool SetPreferredJpegQualities(const StringPiece& qualities); 00315 00316 protected: 00317 bool FetchersComputed() const; 00318 virtual void StopCacheActivity(); 00319 StringPiece filename_prefix(); 00320 00324 bool TerminateServerContext(ServerContext* server_context); 00325 00330 virtual UrlAsyncFetcher* DefaultAsyncUrlFetcher() = 0; 00331 virtual MessageHandler* DefaultHtmlParseMessageHandler() = 0; 00332 virtual MessageHandler* DefaultMessageHandler() = 0; 00333 virtual FileSystem* DefaultFileSystem() = 0; 00334 virtual NonceGenerator* DefaultNonceGenerator(); 00335 virtual Timer* DefaultTimer(); 00336 00337 virtual Hasher* NewHasher() = 0; 00338 00341 virtual ServerContext* NewServerContext() = 0; 00342 00352 virtual ServerContext* NewDecodingServerContext() = 0; 00353 00354 virtual UrlAsyncFetcher* DefaultDistributedUrlFetcher() { return NULL; } 00355 00356 virtual CriticalCssFinder* DefaultCriticalCssFinder(); 00357 virtual CriticalImagesFinder* DefaultCriticalImagesFinder( 00358 ServerContext* server_context); 00359 virtual CriticalSelectorFinder* DefaultCriticalSelectorFinder( 00360 ServerContext* server_context); 00361 00363 virtual CacheHtmlInfoFinder* DefaultCacheHtmlInfoFinder( 00364 PropertyCache* cache, ServerContext* server_context); 00365 00367 virtual FlushEarlyInfoFinder* DefaultFlushEarlyInfoFinder(); 00368 00370 virtual CriticalLineInfoFinder* DefaultCriticalLineInfoFinder( 00371 ServerContext* server_context); 00372 00375 virtual NamedLockManager* DefaultLockManager(); 00376 00379 virtual UrlNamer* DefaultUrlNamer(); 00380 00381 virtual UserAgentMatcher* DefaultUserAgentMatcher(); 00382 virtual UsageDataReporter* DefaultUsageDataReporter(); 00383 00390 virtual void AddPlatformSpecificUserAgentNormalizers( 00391 std::vector<const UserAgentNormalizer*>* out); 00392 00396 virtual QueuedWorkerPool* CreateWorkerPool(WorkerPoolCategory pool, 00397 StringPiece name); 00398 00405 virtual int LowPriorityLoadSheddingThreshold() const; 00406 00409 virtual Scheduler* CreateScheduler(); 00410 00412 virtual void FetcherSetupHooks(); 00413 00417 virtual StringPiece LockFilePrefix(); 00418 00420 virtual void InitStaticAssetManager( 00421 StaticAssetManager* static_asset_manager) {} 00422 00425 void InitStubDecodingServerContext(ServerContext* context); 00426 00428 void RebuildDecodingDriverForTests(ServerContext* server_context); 00429 00430 private: 00434 StaticAssetManager* DefaultStaticAssetManager(); 00435 00436 void SetupSlurpDirectories(); 00437 void Init(); 00438 00439 void InitDecodingDriver(ServerContext* server_context); 00440 00441 scoped_ptr<MessageHandler> html_parse_message_handler_; 00442 scoped_ptr<MessageHandler> message_handler_; 00443 scoped_ptr<FileSystem> file_system_; 00444 UrlAsyncFetcher* url_async_fetcher_; 00445 UrlAsyncFetcher* distributed_async_fetcher_; 00446 scoped_ptr<UrlAsyncFetcher> base_url_async_fetcher_; 00447 scoped_ptr<UrlAsyncFetcher> base_distributed_async_fetcher_; 00448 scoped_ptr<Hasher> hasher_; 00449 scoped_ptr<FilenameEncoder> filename_encoder_; 00450 scoped_ptr<NonceGenerator> nonce_generator_; 00451 scoped_ptr<UrlNamer> url_namer_; 00452 scoped_ptr<UserAgentMatcher> user_agent_matcher_; 00453 00457 std::vector<const UserAgentNormalizer*> user_agent_normalizers_; 00458 scoped_ptr<StaticAssetManager> static_asset_manager_; 00459 scoped_ptr<Timer> timer_; 00460 scoped_ptr<Scheduler> scheduler_; 00461 scoped_ptr<UsageDataReporter> usage_data_reporter_; 00463 const pagespeed::js::JsTokenizerPatterns* js_tokenizer_patterns_; 00464 00465 GoogleString filename_prefix_; 00466 GoogleString slurp_directory_; 00467 bool force_caching_; 00468 bool slurp_read_only_; 00469 bool slurp_print_urls_; 00470 00472 typedef std::set<ServerContext*> ServerContextSet; 00473 ServerContextSet server_contexts_; 00474 scoped_ptr<AbstractMutex> server_context_mutex_; 00475 00478 scoped_ptr<RewriteOptions> default_options_; 00479 00487 scoped_ptr<ServerContext> decoding_server_context_; 00488 scoped_ptr<RewriteDriver> decoding_driver_; 00489 00491 scoped_ptr<NamedLockManager> lock_manager_; 00492 00493 scoped_ptr<ThreadSystem> thread_system_; 00494 00497 NullStatistics null_statistics_; 00498 Statistics* statistics_; 00499 00500 StringSet created_directories_; 00501 00502 std::vector<QueuedWorkerPool*> worker_pools_; 00503 00506 scoped_ptr<RewriteStats> rewrite_stats_; 00507 00510 std::vector<Function*> deferred_cleanups_; 00511 00514 GoogleString version_string_; 00515 00517 GoogleString hostname_; 00518 00523 std::vector<int> preferred_webp_qualities_; 00524 std::vector<int> preferred_jpeg_qualities_; 00525 00526 DISALLOW_COPY_AND_ASSIGN(RewriteDriverFactory); 00527 }; 00528 00531 template<class T> class RewriteDriverFactory::Deleter : public Function { 00532 public: 00533 explicit Deleter(T* obj) : obj_(obj) {} 00534 virtual void Run() { delete obj_; } 00535 private: 00536 T* obj_; 00537 DISALLOW_COPY_AND_ASSIGN(Deleter); 00538 }; 00539 00540 } 00541 00542 #endif ///< NET_INSTAWEB_REWRITER_PUBLIC_REWRITE_DRIVER_FACTORY_H_