1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef NET_HTTP_DISK_CACHE_BASED_SSL_HOST_INFO_H_ 6 #define NET_HTTP_DISK_CACHE_BASED_SSL_HOST_INFO_H_ 7 8 #include <string> 9 10 #include "base/memory/scoped_ptr.h" 11 #include "base/memory/weak_ptr.h" 12 #include "base/threading/non_thread_safe.h" 13 #include "net/base/completion_callback.h" 14 #include "net/disk_cache/disk_cache.h" 15 #include "net/socket/ssl_host_info.h" 16 17 namespace net { 18 19 class HttpCache; 20 class IOBuffer; 21 struct SSLConfig; 22 23 // DiskCacheBasedSSLHostInfo fetches information about an SSL host from our 24 // standard disk cache. Since the information is defined to be non-sensitive, 25 // it's ok for us to keep it on disk. 26 class DiskCacheBasedSSLHostInfo : public SSLHostInfo, 27 public base::NonThreadSafe { 28 public: 29 DiskCacheBasedSSLHostInfo(const std::string& hostname, 30 const SSLConfig& ssl_config, 31 CertVerifier* cert_verifier, 32 HttpCache* http_cache); 33 34 // Implementation of SSLHostInfo 35 virtual void Start(); 36 virtual int WaitForDataReady(CompletionCallback* callback); 37 virtual void Persist(); 38 39 private: 40 enum State { 41 GET_BACKEND, 42 GET_BACKEND_COMPLETE, 43 OPEN, 44 OPEN_COMPLETE, 45 READ, 46 READ_COMPLETE, 47 WAIT_FOR_DATA_READY_DONE, 48 CREATE, 49 CREATE_COMPLETE, 50 WRITE, 51 WRITE_COMPLETE, 52 SET_DONE, 53 NONE, 54 }; 55 56 class CallbackImpl : public CallbackRunner<Tuple1<int> > { 57 public: 58 CallbackImpl(const base::WeakPtr<DiskCacheBasedSSLHostInfo>& obj, 59 void (DiskCacheBasedSSLHostInfo::*meth)(int)); 60 virtual ~CallbackImpl(); 61 backend_pointer()62 disk_cache::Backend** backend_pointer() { return &backend_; } entry_pointer()63 disk_cache::Entry** entry_pointer() { return &entry_; } backend()64 disk_cache::Backend* backend() const { return backend_; } entry()65 disk_cache::Entry* entry() const { return entry_; } 66 67 // CallbackRunner<Tuple1<int> >: 68 virtual void RunWithParams(const Tuple1<int>& params); 69 70 private: 71 base::WeakPtr<DiskCacheBasedSSLHostInfo> obj_; 72 void (DiskCacheBasedSSLHostInfo::*meth_)(int); 73 74 disk_cache::Backend* backend_; 75 disk_cache::Entry* entry_; 76 }; 77 78 virtual ~DiskCacheBasedSSLHostInfo(); 79 80 std::string key() const; 81 82 void DoLoop(int rv); 83 84 int DoGetBackendComplete(int rv); 85 int DoOpenComplete(int rv); 86 int DoReadComplete(int rv); 87 int DoWriteComplete(int rv); 88 int DoCreateComplete(int rv); 89 90 int DoGetBackend(); 91 int DoOpen(); 92 int DoRead(); 93 int DoWrite(); 94 int DoCreate(); 95 96 // WaitForDataReadyDone is the terminal state of the read operation. 97 int WaitForDataReadyDone(); 98 99 // SetDone is the terminal state of the write operation. 100 int SetDone(); 101 102 // IsCallbackPending returns true if we have a pending callback. 103 bool IsCallbackPending() const; 104 105 base::WeakPtrFactory<DiskCacheBasedSSLHostInfo> weak_ptr_factory_; 106 CallbackImpl* callback_; 107 State state_; 108 bool ready_; 109 std::string new_data_; 110 const std::string hostname_; 111 HttpCache* const http_cache_; 112 disk_cache::Backend* backend_; 113 disk_cache::Entry* entry_; 114 CompletionCallback* user_callback_; 115 scoped_refptr<net::IOBuffer> read_buffer_; 116 scoped_refptr<net::IOBuffer> write_buffer_; 117 std::string data_; 118 }; 119 120 } // namespace net 121 122 #endif // NET_HTTP_DISK_CACHE_BASED_SSL_HOST_INFO_H_ 123