resource_combiner.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_RESOURCE_COMBINER_H_
#define NET_INSTAWEB_REWRITER_PUBLIC_RESOURCE_COMBINER_H_

#include "net/instaweb/rewriter/public/resource.h"
#include "net/instaweb/rewriter/public/server_context.h"
#include "net/instaweb/rewriter/public/url_partnership.h"
#include "pagespeed/kernel/base/basictypes.h"
#include "pagespeed/kernel/base/gtest_prod.h"
#include "pagespeed/kernel/base/string.h"
#include "pagespeed/kernel/base/string_util.h"

namespace net_instaweb {

struct ContentType;
class MessageHandler;
class OutputResource;
class RewriteDriver;
class RewriteFilter;
class Writer;

struct TimedBool {
  int64 expiration_ms;
  bool value;
};

class ResourceCombiner {
 public:
  static const int kUrlSlack = 100;

  ResourceCombiner(RewriteDriver* rewrite_driver,
                   const StringPiece& extension,
                   RewriteFilter* filter);

  virtual ~ResourceCombiner();

  void Reset();

  GoogleString UrlSafeId() const;

  int num_urls() const { return partnership_.num_urls(); }

  const ResourceVector& resources() const { return resources_; }

  GoogleString ResolvedBase() const { return partnership_.ResolvedBase(); }

  TimedBool AddResourceNoFetch(const ResourcePtr& resource,
                               MessageHandler* handler);

 protected:
  virtual void RemoveLastResource();

  OutputResourcePtr Combine(MessageHandler* handler);

  virtual bool WriteCombination(const ResourceVector& combine_resources,
                                const OutputResourcePtr& combination,
                                MessageHandler* handler);

  virtual bool WritePiece(int index, int num_pieces, const Resource* input,
                          OutputResource* combination, Writer* writer,
                          MessageHandler* handler);

  virtual void Clear();

  ServerContext* const server_context_;
  RewriteDriver* const rewrite_driver_;

 private:
  friend class AggregateCombiner;

  virtual const ContentType* CombinationContentType() = 0;

  void UpdateResolvedBase();

  void ComputeLeafSize();

  void AccumulateLeafSize(const StringPiece& url);

  bool UrlTooBig();

  virtual void AccumulateCombinedSize(const ResourcePtr& resource) {}

  virtual bool ContentSizeTooBig() const { return false; }

  virtual bool ResourceCombinable(Resource* resource,
                                  GoogleString* failure_reason,
                                  MessageHandler* handler);

  UrlPartnership partnership_;
  ResourceVector resources_;
  StringVector multipart_encoder_urls_;
  int prev_num_components_;
  int accumulated_leaf_size_;
  GoogleString resolved_base_;
  const int url_overhead_;
  RewriteFilter* filter_;

  FRIEND_TEST(ResourceCombinerTest, TestRemove);
  FRIEND_TEST(ResourceCombinerTest, TestRemoveFrom3);
  FRIEND_TEST(ResourceCombinerTest, TestRebaseRemove);
  FRIEND_TEST(ResourceCombinerTest, TestRebaseRemoveAdd);

  
};

}  

#endif