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/command_line.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/utf_string_conversions.h"
 #include "sql/connection.h"
 #include "sql/meta_table.h"
 #include "sql/statement.h"
 #include "sql/transaction.h"
 #include "webkit/appcache/appcache_entry.h"
 #include "webkit/appcache/appcache_histograms.h"
 
+namespace appcache {
+
 // Schema -------------------------------------------------------------------
 namespace {
 
 const int kCurrentVersion = 5;
 const int kCompatibleVersion = 5;
 
 // A mechanism to run experiments that may affect in data being persisted
 // in different ways such that when the experiment is toggled on/off via
 // cmd line flags, the database gets reset. The active flags are stored at
 // the time of database creation and compared when reopening. If different
@@ skipping 132 matching lines @@
   else
     sql += "CREATE INDEX ";
   sql += info.index_name;
   sql += " ON ";
   sql += info.table_name;
   sql += info.columns;
   return db->Execute(sql.c_str());
 }
 
 std::string GetActiveExperimentFlags() {
+  if (CommandLine::ForCurrentProcess()->HasSwitch(kEnableExecutableHandlers))
+    return std::string("executableHandlersEnabled");
   return std::string();
 }
 
 }  // anon namespace
 
 // AppCacheDatabase ----------------------------------------------------------
-namespace appcache {
 
 AppCacheDatabase::GroupRecord::GroupRecord()
     : group_id(0) {
 }
 
 AppCacheDatabase::GroupRecord::~GroupRecord() {
 }
 
 AppCacheDatabase::NamespaceRecord::NamespaceRecord()
     : cache_id(0) {
@@ skipping 506 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.
+  int type_with_executable_bit = record->namespace_.type;
+  if (record->namespace_.is_executable) {
+    type_with_executable_bit |= 0x8000000;
+    DCHECK(CommandLine::ForCurrentProcess()->HasSwitch(
+        kEnableExecutableHandlers));
+  }
+
   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_executable_bit = statement->ColumnInt(2);

[michaeln, 2013/04/16 22:25:11]

could make this const to make it more clear we don't fiddle the bits in this
value in the logic below

   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_executable_bit & 0x7ffffff);
+  record->namespace_.is_executable =
+      (type_with_executable_bit & 0x80000000) != 0;
+  DCHECK(!record->namespace_.is_executable ||
+      CommandLine::ForCurrentProcess()->HasSwitch(kEnableExecutableHandlers));
 }
 
 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 211 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