extensions/browser/app_window/app_window_geometry_cache.cc

   1 // Copyright 2014 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 #include "extensions/browser/app_window/app_window_geometry_cache.h"
   6
   7 #include "base/bind.h"
   8 #include "base/stl_util.h"
   9 #include "base/strings/string_number_conversions.h"
  10 #include "components/keyed_service/content/browser_context_dependency_manager.h"
  11 #include "extensions/browser/extension_prefs.h"
  12 #include "extensions/browser/extension_prefs_factory.h"
  13 #include "extensions/browser/extension_registry.h"
  14 #include "extensions/browser/extensions_browser_client.h"
  15 #include "extensions/common/extension.h"
  16
  17 namespace {
  18
  19 // The timeout in milliseconds before we'll persist window geometry to the
  20 // StateStore.
  21 const int kSyncTimeoutMilliseconds = 1000;
  22
  23 }  // namespace
  24
  25 namespace extensions {
  26
  27 AppWindowGeometryCache::AppWindowGeometryCache(content::BrowserContext* context,
  28                                                ExtensionPrefs* prefs)
  29     : prefs_(prefs),
  30       sync_delay_(base::TimeDelta::FromMilliseconds(kSyncTimeoutMilliseconds)),
  31       extension_registry_observer_(this) {
  32   extension_registry_observer_.Add(ExtensionRegistry::Get(context));
  33 }
  34
  35 AppWindowGeometryCache::~AppWindowGeometryCache() {}
  36
  37 // static
  38 AppWindowGeometryCache* AppWindowGeometryCache::Get(
  39     content::BrowserContext* context) {
  40   return Factory::GetForContext(context, true /* create */);
  41 }
  42
  43 void AppWindowGeometryCache::SaveGeometry(const std::string& extension_id,
  44                                           const std::string& window_id,
  45                                           const gfx::Rect& bounds,
  46                                           const gfx::Rect& screen_bounds,
  47                                           ui::WindowShowState window_state) {
  48   ExtensionData& extension_data = cache_[extension_id];
  49
  50   // If we don't have any unsynced changes and this is a duplicate of what's
  51   // already in the cache, just ignore it.
  52   if (extension_data[window_id].bounds == bounds &&
  53       extension_data[window_id].window_state == window_state &&
  54       extension_data[window_id].screen_bounds == screen_bounds &&
  55       !ContainsKey(unsynced_extensions_, extension_id))
  56     return;
  57
  58   base::Time now = base::Time::Now();
  59
  60   extension_data[window_id].bounds = bounds;
  61   extension_data[window_id].screen_bounds = screen_bounds;
  62   extension_data[window_id].window_state = window_state;
  63   extension_data[window_id].last_change = now;
  64
  65   if (extension_data.size() > kMaxCachedWindows) {
  66     ExtensionData::iterator oldest = extension_data.end();
  67     // Too many windows in the cache, find the oldest one to remove.
  68     for (ExtensionData::iterator it = extension_data.begin();
  69          it != extension_data.end();
  70          ++it) {
  71       // Don't expunge the window that was just added.
  72       if (it->first == window_id)
  73         continue;
  74
  75       // If time is in the future, reset it to now to minimize weirdness.
  76       if (it->second.last_change > now)
  77         it->second.last_change = now;
  78
  79       if (oldest == extension_data.end() ||
  80           it->second.last_change < oldest->second.last_change)
  81         oldest = it;
  82     }
  83     extension_data.erase(oldest);
  84   }
  85
  86   unsynced_extensions_.insert(extension_id);
  87
  88   // We don't use Reset() because the timer may not yet be running.
  89   // (In that case Stop() is a no-op.)
  90   sync_timer_.Stop();
  91   sync_timer_.Start(
  92       FROM_HERE, sync_delay_, this, &AppWindowGeometryCache::SyncToStorage);
  93 }
  94
  95 void AppWindowGeometryCache::SyncToStorage() {
  96   std::set<std::string> tosync;
  97   tosync.swap(unsynced_extensions_);
  98   for (std::set<std::string>::const_iterator it = tosync.begin(),
  99                                              eit = tosync.end();
 100        it != eit;
 101        ++it) {
 102     const std::string& extension_id = *it;
 103     const ExtensionData& extension_data = cache_[extension_id];
 104
 105     scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue);
 106     for (ExtensionData::const_iterator it = extension_data.begin(),
 107                                        eit = extension_data.end();
 108          it != eit;
 109          ++it) {
 110       base::DictionaryValue* value = new base::DictionaryValue;
 111       const gfx::Rect& bounds = it->second.bounds;
 112       const gfx::Rect& screen_bounds = it->second.screen_bounds;
 113       DCHECK(!bounds.IsEmpty());
 114       DCHECK(!screen_bounds.IsEmpty());
 115       DCHECK(it->second.window_state != ui::SHOW_STATE_DEFAULT);
 116       value->SetInteger("x", bounds.x());
 117       value->SetInteger("y", bounds.y());
 118       value->SetInteger("w", bounds.width());
 119       value->SetInteger("h", bounds.height());
 120       value->SetInteger("screen_bounds_x", screen_bounds.x());
 121       value->SetInteger("screen_bounds_y", screen_bounds.y());
 122       value->SetInteger("screen_bounds_w", screen_bounds.width());
 123       value->SetInteger("screen_bounds_h", screen_bounds.height());
 124       value->SetInteger("state", it->second.window_state);
 125       value->SetString(
 126           "ts", base::Int64ToString(it->second.last_change.ToInternalValue()));
 127       dict->SetWithoutPathExpansion(it->first, value);
 128
 129       FOR_EACH_OBSERVER(
 130           Observer,
 131           observers_,
 132           OnGeometryCacheChanged(extension_id, it->first, bounds));
 133     }
 134
 135     prefs_->SetGeometryCache(extension_id, dict.Pass());
 136   }
 137 }
 138
 139 bool AppWindowGeometryCache::GetGeometry(const std::string& extension_id,
 140                                          const std::string& window_id,
 141                                          gfx::Rect* bounds,
 142                                          gfx::Rect* screen_bounds,
 143                                          ui::WindowShowState* window_state) {
 144   std::map<std::string, ExtensionData>::const_iterator extension_data_it =
 145       cache_.find(extension_id);
 146
 147   // Not in the map means loading data for the extension didn't finish yet or
 148   // the cache was not constructed until after the extension was loaded.
 149   // Attempt to load from sync to address the latter case.
 150   if (extension_data_it == cache_.end()) {
 151     LoadGeometryFromStorage(extension_id);
 152     extension_data_it = cache_.find(extension_id);
 153     DCHECK(extension_data_it != cache_.end());
 154   }
 155
 156   ExtensionData::const_iterator window_data_it =
 157       extension_data_it->second.find(window_id);
 158
 159   if (window_data_it == extension_data_it->second.end())
 160     return false;
 161
 162   const WindowData& window_data = window_data_it->second;
 163
 164   // Check for and do not return corrupt data.
 165   if ((bounds && window_data.bounds.IsEmpty()) ||
 166       (screen_bounds && window_data.screen_bounds.IsEmpty()) ||
 167       (window_state && window_data.window_state == ui::SHOW_STATE_DEFAULT))
 168     return false;
 169
 170   if (bounds)
 171     *bounds = window_data.bounds;
 172   if (screen_bounds)
 173     *screen_bounds = window_data.screen_bounds;
 174   if (window_state)
 175     *window_state = window_data.window_state;
 176   return true;
 177 }
 178
 179 void AppWindowGeometryCache::Shutdown() { SyncToStorage(); }
 180
 181 AppWindowGeometryCache::WindowData::WindowData()
 182     : window_state(ui::SHOW_STATE_DEFAULT) {}
 183
 184 AppWindowGeometryCache::WindowData::~WindowData() {}
 185
 186 void AppWindowGeometryCache::OnExtensionLoaded(
 187     content::BrowserContext* browser_context,
 188     const Extension* extension) {
 189   LoadGeometryFromStorage(extension->id());
 190 }
 191
 192 void AppWindowGeometryCache::OnExtensionUnloaded(
 193     content::BrowserContext* browser_context,
 194     const Extension* extension,
 195     UnloadedExtensionInfo::Reason reason) {
 196   SyncToStorage();
 197   cache_.erase(extension->id());
 198 }
 199
 200 void AppWindowGeometryCache::SetSyncDelayForTests(int timeout_ms) {
 201   sync_delay_ = base::TimeDelta::FromMilliseconds(timeout_ms);
 202 }
 203
 204 void AppWindowGeometryCache::LoadGeometryFromStorage(
 205     const std::string& extension_id) {
 206   ExtensionData& extension_data = cache_[extension_id];
 207
 208   const base::DictionaryValue* stored_windows =
 209       prefs_->GetGeometryCache(extension_id);
 210   if (!stored_windows)
 211     return;
 212
 213   for (base::DictionaryValue::Iterator it(*stored_windows); !it.IsAtEnd();
 214        it.Advance()) {
 215     // If the cache already contains geometry for this window, don't
 216     // overwrite that information since it is probably the result of an
 217     // application starting up very quickly.
 218     const std::string& window_id = it.key();
 219     ExtensionData::iterator cached_window = extension_data.find(window_id);
 220     if (cached_window == extension_data.end()) {
 221       const base::DictionaryValue* stored_window;
 222       if (it.value().GetAsDictionary(&stored_window)) {
 223         WindowData& window_data = extension_data[it.key()];
 224
 225         int i;
 226         if (stored_window->GetInteger("x", &i))
 227           window_data.bounds.set_x(i);
 228         if (stored_window->GetInteger("y", &i))
 229           window_data.bounds.set_y(i);
 230         if (stored_window->GetInteger("w", &i))
 231           window_data.bounds.set_width(i);
 232         if (stored_window->GetInteger("h", &i))
 233           window_data.bounds.set_height(i);
 234         if (stored_window->GetInteger("screen_bounds_x", &i))
 235           window_data.screen_bounds.set_x(i);
 236         if (stored_window->GetInteger("screen_bounds_y", &i))
 237           window_data.screen_bounds.set_y(i);
 238         if (stored_window->GetInteger("screen_bounds_w", &i))
 239           window_data.screen_bounds.set_width(i);
 240         if (stored_window->GetInteger("screen_bounds_h", &i))
 241           window_data.screen_bounds.set_height(i);
 242         if (stored_window->GetInteger("state", &i)) {
 243           window_data.window_state = static_cast<ui::WindowShowState>(i);
 244         }
 245         std::string ts_as_string;
 246         if (stored_window->GetString("ts", &ts_as_string)) {
 247           int64 ts;
 248           if (base::StringToInt64(ts_as_string, &ts)) {
 249             window_data.last_change = base::Time::FromInternalValue(ts);
 250           }
 251         }
 252       }
 253     }
 254   }
 255 }
 256
 257 ///////////////////////////////////////////////////////////////////////////////
 258 // Factory boilerplate
 259
 260 // static
 261 AppWindowGeometryCache* AppWindowGeometryCache::Factory::GetForContext(
 262     content::BrowserContext* context,
 263     bool create) {
 264   return static_cast<AppWindowGeometryCache*>(
 265       GetInstance()->GetServiceForBrowserContext(context, create));
 266 }
 267
 268 AppWindowGeometryCache::Factory*
 269 AppWindowGeometryCache::Factory::GetInstance() {
 270   return Singleton<AppWindowGeometryCache::Factory>::get();
 271 }
 272
 273 AppWindowGeometryCache::Factory::Factory()
 274     : BrowserContextKeyedServiceFactory(
 275           "AppWindowGeometryCache",
 276           BrowserContextDependencyManager::GetInstance()) {
 277   DependsOn(ExtensionPrefsFactory::GetInstance());
 278 }
 279
 280 AppWindowGeometryCache::Factory::~Factory() {}
 281
 282 KeyedService* AppWindowGeometryCache::Factory::BuildServiceInstanceFor(
 283     content::BrowserContext* context) const {
 284   return new AppWindowGeometryCache(context, ExtensionPrefs::Get(context));
 285 }
 286
 287 bool AppWindowGeometryCache::Factory::ServiceIsNULLWhileTesting() const {
 288   return false;
 289 }
 290
 291 content::BrowserContext*
 292 AppWindowGeometryCache::Factory::GetBrowserContextToUse(
 293     content::BrowserContext* context) const {
 294   return ExtensionsBrowserClient::Get()->GetOriginalContext(context);
 295 }
 296
 297 void AppWindowGeometryCache::AddObserver(Observer* observer) {
 298   observers_.AddObserver(observer);
 299 }
 300
 301 void AppWindowGeometryCache::RemoveObserver(Observer* observer) {
 302   observers_.RemoveObserver(observer);
 303 }
 304
 305 }  // namespace extensions