AppCacheExecutableHandlers - parse manifest file and store the 'bit' indicating executable.

webkit/appcache/appcache_database.cc

 // Copyright (c) 2012 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 "webkit/appcache/appcache_database.h"
 
 #include "base/auto_reset.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/utf_string_conversions.h"
@@ skipping 671 matching lines @@
 bool AppCacheDatabase::InsertNamespace(
     const NamespaceRecord* record) {
   if (!LazyOpen(true))
     return false;
 
   const char* kSql =
       "INSERT INTO Namespaces"
       "  (cache_id, origin, type, namespace_url, target_url, is_pattern)"
       "  VALUES (?, ?, ?, ?, ?, ?)";
 
+  // Note: quick and dirty storage for the 'executable' bit w/o changing
+  // schemas, we use the high bit of 'type' field

[Greg Billock, 2013/04/10 23:25:30]

Is this going to give us maintenance hassles later? I know a new schema will,
but how much of a price is this? I don't know namespace.type

[alecflett, 2013/04/10 23:39:56]

Yeah, for instance we lose backwards compatibility in unusual ways - if this
gets backed out mid-milestone, this out is going to be ugly because old/new code
doesn't know that the high bit is set.

[michaeln, 2013/04/10 23:47:59]

This bugs me too :) We couldn't completely back everything one this goes in,
we'd have to leave the code that masks off the high bit forever.

Maybe we can simply not put this bit in this table for now? The entry.flags
field also has this new bit and that is what AppCacheUrlRequestJob is looking at
anyway. The bit in the Namespace struct would not survive roundtrips to and from
the db, but that seems ok for now. The important part is that the bit in Entry
does survive roundtrips. Still a little sloppy, but with less persistence. 

+  int type_with_executable_bit = record->namespace_.type;
+  if (record->namespace_.is_executable)
+    type_with_executable_bit |= 0x80000000;
+
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt64(0, record->cache_id);
   statement.BindString(1, record->origin.spec());
-  statement.BindInt(2, record->namespace_.type);
+  statement.BindInt(2, type_with_executable_bit);
   statement.BindString(3, record->namespace_.namespace_url.spec());
   statement.BindString(4, record->namespace_.target_url.spec());
   statement.BindBool(5, record->namespace_.is_pattern);
   return statement.Run();
 }
 
 bool AppCacheDatabase::InsertNamespaceRecords(
     const std::vector<NamespaceRecord>& records) {
   if (records.empty())
     return true;
@@ skipping 223 matching lines @@
         (type == FALLBACK_NAMESPACE) ? fallbacks : intercepts;
     records->push_back(NamespaceRecord());
     ReadNamespaceRecord(statement, &records->back());
   }
 }
 
 void AppCacheDatabase::ReadNamespaceRecord(
     const sql::Statement* statement, NamespaceRecord* record) {
   record->cache_id = statement->ColumnInt64(0);
   record->origin = GURL(statement->ColumnString(1));
-  record->namespace_.type = static_cast<NamespaceType>(statement->ColumnInt(2));
+  int type_with_excutable_bit = statement->ColumnInt(2);
   record->namespace_.namespace_url = GURL(statement->ColumnString(3));
   record->namespace_.target_url = GURL(statement->ColumnString(4));
   record->namespace_.is_pattern = statement->ColumnBool(5);
+
+  // Note: quick and dirty storage for the 'executable' bit w/o changing
+  // schemas, we use the high bit of 'type' field.
+  record->namespace_.type = static_cast<NamespaceType>
+      (type_with_excutable_bit & 0x7ffffffff);
+  record->namespace_.is_executable =
+      (type_with_excutable_bit & 0x80000000) != 0;
 }
 
 void AppCacheDatabase::ReadOnlineWhiteListRecord(
     const sql::Statement& statement, OnlineWhiteListRecord* record) {
   record->cache_id = statement.ColumnInt64(0);
   record->namespace_url = GURL(statement.ColumnString(1));
   record->is_pattern = statement.ColumnBool(2);
 }
 
 bool AppCacheDatabase::LazyOpen(bool create_if_needed) {
@@ skipping 201 matching lines @@
 
   // So we can't go recursive.
   if (is_recreating_)
     return false;
 
   base::AutoReset<bool> auto_reset(&is_recreating_, true);
   return LazyOpen(true);
 }
 
 }  // namespace appcache