More groundwork for flat file based response storage.

webkit/appcache/view_appcache_internals_job.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <algorithm>
 #include <string>
 
 #include "webkit/appcache/view_appcache_internals_job.h"
 
 #include "base/base64.h"
@@ skipping 167 matching lines @@
     str.append("Fallback, ");
   if (info.is_explicit)
     str.append("Explicit, ");
   if (info.is_foreign)
     str.append("Foreign, ");
   return str;
 }
 
 std::string FormViewEntryAnchor(const GURL& base_url,
                                 const GURL& manifest_url, const GURL& entry_url,
-                                int64 response_id) {
+                                int64 response_id,
+                                int64 group_id) {
   std::string manifest_url_base64;
   std::string entry_url_base64;
   std::string response_id_string;
+  std::string group_id_string;
   base::Base64Encode(manifest_url.spec(), &manifest_url_base64);
   base::Base64Encode(entry_url.spec(), &entry_url_base64);
   response_id_string = base::Int64ToString(response_id);
+  group_id_string = base::Int64ToString(group_id);
 
   std::string query(kViewEntryCommand);
   query.push_back('=');
   query.append(manifest_url_base64);
   query.push_back('|');
   query.append(entry_url_base64);
   query.push_back('|');
   query.append(response_id_string);
+  query.push_back('|');
+  query.append(group_id_string);
 
   GURL::Replacements replacements;
   replacements.SetQuery(query.data(),
                         url_parse::Component(0, query.length()));
   GURL view_entry_url = base_url.ReplaceComponents(replacements);
 
   std::string anchor;
   EmitAnchor(view_entry_url.spec(), entry_url.spec(), &anchor);
   return anchor;
 }
 
 void EmitAppCacheResourceInfoVector(
     const GURL& base_url,
     const GURL& manifest_url,
     const AppCacheResourceInfoVector& resource_infos,
+    int64 group_id,
     std::string* out) {
   out->append("<table border='0'>\n");
   out->append("<tr>");
   EmitTableData("Flags", false, true, out);
   EmitTableData("URL", false, true, out);
   EmitTableData("Size (headers and data)", true, true, out);
   out->append("</tr>\n");
   for (AppCacheResourceInfoVector::const_iterator
           iter = resource_infos.begin();
        iter != resource_infos.end(); ++iter) {
     out->append("<tr>");
     EmitTableData(FormFlagsString(*iter), false, false, out);
     EmitTableData(FormViewEntryAnchor(base_url, manifest_url,
-                                      iter->url, iter->response_id),
+                                      iter->url, iter->response_id,
+                                      group_id),
                   false, false, out);
     EmitTableData(UTF16ToUTF8(FormatBytesUnlocalized(iter->size)),
                   true, false, out);
     out->append("</tr>\n");
   }
   out->append("</table>\n");
 }
 
 void EmitResponseHeaders(net::HttpResponseHeaders* headers, std::string* out) {
   out->append("<hr><pre>");
@@ skipping 206 matching lines @@
     charset->assign("UTF-8");
     out->clear();
     EmitPageStart(out);
     if (appcache_info_.manifest_url.is_empty()) {
       out->append(kManifestNotFoundMessage);
     } else {
       GURL base_url = ClearQuery(request_->url());
       EmitAppCacheInfo(base_url, appcache_service_, &appcache_info_, out);
       EmitAppCacheResourceInfoVector(base_url,
                                      manifest_url_,
-                                     resource_infos_, out);
+                                     resource_infos_,
+                                     appcache_info_.group_id,
+                                     out);
     }
     EmitPageEnd(out);
     return true;
   }
 
  private:
   virtual ~ViewAppCacheJob() {
     appcache_service_->storage()->CancelDelegateCallbacks(this);
   }
 
   // AppCacheStorage::Delegate override
   virtual void OnGroupLoaded(
       AppCacheGroup* group, const GURL& manifest_url) OVERRIDE {
     DCHECK_EQ(manifest_url_, manifest_url);
     if (group && group->newest_complete_cache()) {
       appcache_info_.manifest_url = manifest_url;
+      appcache_info_.group_id = group->group_id();
       appcache_info_.size = group->newest_complete_cache()->cache_size();
       appcache_info_.creation_time = group->creation_time();
       appcache_info_.last_update_time =
           group->newest_complete_cache()->update_time();
       appcache_info_.last_access_time = base::Time::Now();
       group->newest_complete_cache()->ToResourceInfoVector(&resource_infos_);
       std::sort(resource_infos_.begin(), resource_infos_.end(),
                 SortByResourceUrl);
     }
     StartAsync();
   }
 
   GURL manifest_url_;
   AppCacheInfo appcache_info_;
   AppCacheResourceInfoVector resource_infos_;
   DISALLOW_COPY_AND_ASSIGN(ViewAppCacheJob);
 };
 
 // Job that shows the details of a particular cached resource.
 class ViewEntryJob : public BaseInternalsJob,
                      public AppCacheStorage::Delegate {
  public:
   ViewEntryJob(
       net::URLRequest* request, AppCacheService* service,
       const GURL& manifest_url, const GURL& entry_url,
-      int64 response_id)
+      int64 response_id, int64 group_id)
       : BaseInternalsJob(request, service),
         manifest_url_(manifest_url), entry_url_(entry_url),
-        response_id_(response_id), amount_read_(0),
+        response_id_(response_id), group_id_(group_id), amount_read_(0),
         ALLOW_THIS_IN_INITIALIZER_LIST(read_callback_(
             this, &ViewEntryJob::OnReadComplete)) {}
 
   virtual void Start() {
     DCHECK(request_);
     appcache_service_->storage()->LoadResponseInfo(
-        manifest_url_, response_id_, this);
+        manifest_url_, group_id_, response_id_, this);
   }
 
   // Produces a page containing the response headers and data.
   virtual bool GetData(std::string* mime_type,
                        std::string* charset,
                        std::string* out) const {
     mime_type->assign("text/html");
     charset->assign("UTF-8");
     out->clear();
     EmitPageStart(out);
@@ skipping 31 matching lines @@
     }
     response_info_ = response_info;
 
     // Read the response data, truncating if its too large.
     const int64 kLimit = 100 * 1000;
     int64 amount_to_read =
         std::min(kLimit, response_info->response_data_size());
     response_data_ = new net::IOBuffer(amount_to_read);
 
     reader_.reset(appcache_service_->storage()->CreateResponseReader(
-        manifest_url_, response_id_));
+        manifest_url_, group_id_, response_id_));
     reader_->ReadData(
         response_data_, amount_to_read, &read_callback_);
   }
 
   void OnReadComplete(int result) {
     reader_.reset();
     amount_read_ = result;
     if (result < 0)
       response_data_ = NULL;
     StartAsync();
   }
 
   GURL manifest_url_;
   GURL entry_url_;
   int64 response_id_;
+  int64 group_id_;
   scoped_refptr<AppCacheResponseInfo> response_info_;
   scoped_refptr<net::IOBuffer> response_data_;
   int amount_read_;
   scoped_ptr<AppCacheResponseReader> reader_;
   net::OldCompletionCallbackImpl<ViewEntryJob> read_callback_;
 };
 
 }  // namespace
 
 net::URLRequestJob* ViewAppCacheInternalsJobFactory::CreateJobForRequest(
     net::URLRequest* request,  AppCacheService* service) {
   if (!request->url().has_query())
     return new MainPageJob(request, service);
 
   std::string command;
   std::string param;
   ParseQuery(request->url().query(), &command, &param);
 
   if (command == kRemoveCacheCommand)
     return new RemoveAppCacheJob(request, service,
                                  DecodeBase64URL(param));
 
   if (command == kViewCacheCommand)
     return new ViewAppCacheJob(request, service,
                                DecodeBase64URL(param));
 
   std::vector<std::string> tokens;
   int64 response_id;
-  if (command == kViewEntryCommand &&
-      Tokenize(param, "|", &tokens) == 3u &&
-      base::StringToInt64(tokens[2], &response_id)) {
+  int64 group_id;
+  if (command == kViewEntryCommand && Tokenize(param, "|", &tokens) == 4u &&
+      base::StringToInt64(tokens[2], &response_id) &&
+      base::StringToInt64(tokens[3], &group_id)) {
     return new ViewEntryJob(request, service,
                             DecodeBase64URL(tokens[0]),  // manifest url
                             DecodeBase64URL(tokens[1]),  // entry url
-                            response_id);
+                            response_id, group_id);
   }
 
   return new RedirectToMainPageJob(request, service);
 }
 
 }  // namespace appcache