[WIP] histroy: Adjust cache size OnMemoryStateChange()

sql/connection.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 "sql/connection.h"
 
 #include <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
@@ skipping 976 matching lines @@
   if (!Execute(sql_shrink.c_str()))
     DLOG(WARNING) << "Could not shrink cache size: " << GetErrorMessage();
 
   // Restore cache size.
   const std::string sql_restore =
       base::StringPrintf("PRAGMA cache_size=%d", original_cache_size);
   if (!Execute(sql_restore.c_str()))
     DLOG(WARNING) << "Could not restore cache size: " << GetErrorMessage();
 }
 
+bool Connection::UpdateCacheSize(int new_cache_size) {
+  if (!db_)
+    return false;
+  if (cache_size_ == new_cache_size)
+    return true;

[Scott Hess - ex-Googler, 2016/09/01 18:29:09]

I think this is fine, but might not even be worth checking.  You could just put:

  cache_size_ = new_cache_size;
  const std::string sql = ...;
  return Execute(sql.c_str());

Yes, that might allow for cases where cache_size_ doesn't equal the _actual_
cache size SQLite is using, but AFAICT that is already the case, and I don't
think any code depends on cache_size_ anyhow.  AFAICT, the pragma doesn't have
any provision for errors to be propagated, and the docs explicitly indicate that
the cache_size is in some sense advisory.

+
+  const std::string sql =
+      base::StringPrintf("PRAGMA cache_size=%d", new_cache_size);
+  if (!Execute(sql.c_str())) {
+    DLOG(WARNING) << "Could not update cache size: " << GetErrorMessage();

[Scott Hess - ex-Googler, 2016/09/01 18:29:09]

Execute() will already emit messages in case of errors.  See OnSqliteError(). 
This message would, of course, be ever-so-slightly more on-topic, but, honestly,
nobody is ever going to see it so I'd not bother.

+    return false;
+  }
+  cache_size_ = new_cache_size;
+  return true;
+}
+
 // Create an in-memory database with the existing database's page
 // size, then backup that database over the existing database.
 bool Connection::Raze() {
   AssertIOAllowed();
 
   if (!db_) {
     DLOG_IF(FATAL, !poisoned_) << "Cannot raze null db";
     return false;
   }
 
@@ skipping 980 matching lines @@
   ignore_result(Execute(kNoWritableSchema));
 
   return ret;
 }
 
 base::TimeTicks TimeSource::Now() {
   return base::TimeTicks::Now();
 }
 
 }  // namespace sql