output_resource.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_OUTPUT_RESOURCE_H_
#define NET_INSTAWEB_REWRITER_PUBLIC_OUTPUT_RESOURCE_H_

#include "base/logging.h"
#include "net/instaweb/http/public/request_context.h"
#include "net/instaweb/rewriter/public/output_resource_kind.h"
#include "net/instaweb/rewriter/public/resource.h"
#include "net/instaweb/rewriter/public/resource_namer.h"
#include "pagespeed/kernel/base/basictypes.h"
#include "pagespeed/kernel/base/ref_counted_ptr.h"
#include "pagespeed/kernel/base/string.h"
#include "pagespeed/kernel/base/string_util.h"

namespace net_instaweb {

class CachedResult;
class MessageHandler;
class RewriteDriver;
class RewriteOptions;
class Writer;
struct ContentType;

class OutputResource : public Resource {
 public:
  OutputResource(const RewriteDriver* driver,
                 StringPiece resolved_base,
                 StringPiece unmapped_base, 
                 StringPiece original_base, 
                 const ResourceNamer& resource_id,
                 OutputResourceKind kind);

  virtual void LoadAndCallback(NotCacheablePolicy not_cacheable_policy,
                               const RequestContextPtr& request_context,
                               AsyncCallback* callback);
  virtual GoogleString url() const;
  GoogleString UrlEvenIfHashNotSet();

  void DumpToDisk(MessageHandler* handler);

  void UpdateCachedResultPreservingInputInfo(CachedResult* to_update) const;

  virtual GoogleString name_key() const;

  GoogleString HttpCacheKey() const;

  const GoogleString& resolved_base() const { return resolved_base_; }
  const GoogleString& unmapped_base() const { return unmapped_base_; }
  const GoogleString& original_base() const { return original_base_; }
  const ResourceNamer& full_name() const { return full_name_; }
  ResourceNamer* mutable_full_name() { return &full_name_; }
  StringPiece name() const { return full_name_.name(); }
  StringPiece experiment() const { return full_name_.experiment(); }
  StringPiece suffix() const;
  StringPiece filter_prefix() const { return full_name_.id(); }
  StringPiece hash() const { return full_name_.hash(); }
  StringPiece signature() const { return full_name_.signature(); }
  bool has_hash() const { return !hash().empty(); }
  void clear_hash() {
    full_name_.ClearHash();
    computed_url_.clear();
  }

  GoogleString decoded_base() const;

  bool IsWritten() const { return writing_complete_; }

  virtual void SetType(const ContentType* type);

  const CachedResult* cached_result() const { return cached_result_; }

  CachedResult* EnsureCachedResultCreated();

  void clear_cached_result();

  void set_cached_result(CachedResult* cached_result) {
    clear_cached_result();
    cached_result_ = cached_result;
  }

  OutputResourceKind kind() const { return kind_; }

  void SetWritten(bool written) { writing_complete_ = true; }

  virtual const RewriteOptions* rewrite_options() const {
    return rewrite_options_;
  }

  Writer* BeginWrite(MessageHandler* message_handler);
  void EndWrite(MessageHandler* message_handler);

  virtual bool UseHttpCache() const { return true; }

  const GoogleString& cache_control_suffix() const {
    return cache_control_suffix_;
  }
  void set_cache_control_suffix(const GoogleString& x) {
    DCHECK(cache_control_suffix_.empty());
    cache_control_suffix_ = x;
  }

 protected:
  virtual ~OutputResource();
  REFCOUNT_FRIEND_DECLARATION(OutputResource);

 private:
  friend class RewriteDriver;
  friend class ServerContext;
  friend class ServerContextTest;

  void SetHash(StringPiece hash);
  StringPiece extension() const { return full_name_.ext(); }
  GoogleString ComputeSignature();
  bool CheckSignature();

  GoogleString DumpFileName() const;

  bool writing_complete_;

  bool cached_result_owned_;
  CachedResult* cached_result_;

  GoogleString resolved_base_;
  GoogleString unmapped_base_;
  GoogleString original_base_;

  GoogleString cache_control_suffix_;

  ResourceNamer full_name_;

  mutable GoogleString computed_url_;

  const RewriteOptions* rewrite_options_;

  OutputResourceKind kind_;

  
};

}  

#endif