InstantExtended: Adding InstantRestrictedIDCache.

chrome/browser/search/instant_service.cc

 // Copyright 2013 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 "chrome/browser/search/instant_service.h"
 
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/history/history_notifications.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search/instant_io_context.h"
 #include "chrome/browser/search/instant_service_factory.h"
 #include "chrome/browser/search/local_omnibox_popup_source.h"
 #include "chrome/browser/ui/webui/favicon_source.h"
 #include "chrome/browser/ui/webui/ntp/thumbnail_source.h"
 #include "chrome/browser/ui/webui/theme_source.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/url_data_source.h"
 #include "googleurl/src/gurl.h"
 #include "net/url_request/url_request.h"
 
 using content::BrowserThread;
 
-namespace {
-
-// Copies deleted urls out of the history data structure |details| into a
-// straight vector of GURLs.
-void HistoryDetailsToDeletedURLs(const history::URLsDeletedDetails& details,
-                                 std::vector<GURL>* deleted_urls) {
-  for (history::URLRows::const_iterator it = details.rows.begin();
-       it != details.rows.end();
-       ++it) {
-    deleted_urls->push_back(it->url());
-  }
-}
-
-}  // namespace
-
 InstantService::InstantService(Profile* profile)
     : profile_(profile),
-      last_most_visited_item_id_(0) {
+      most_visited_item_cache_(kMaxInstantMostVisitedItemCacheSize) {
   // Stub for unit tests.
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI))
     return;
 
   registrar_.Add(this,
                  content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
                  content::NotificationService::AllSources());
-  registrar_.Add(this,
-                 chrome::NOTIFICATION_HISTORY_URLS_DELETED,
-                 content::NotificationService::AllSources());
 
   instant_io_context_ = new InstantIOContext();
 
   if (profile_ && profile_->GetResourceContext()) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&InstantIOContext::SetUserDataOnIO,
                    profile->GetResourceContext(), instant_io_context_));
   }
 
@@ skipping 12 matching lines @@
 
 // static
 const std::string InstantService::MaybeTranslateInstantPathOnUI(
     Profile* profile, const std::string& path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   InstantService* instant_service =
       InstantServiceFactory::GetForProfile(profile);
   if (!instant_service)
     return path;
 
-  uint64 most_visited_item_id = 0;
-  if (base::StringToUint64(path, &most_visited_item_id)) {
-    GURL url;
-    if (instant_service->GetURLForMostVisitedItemId(most_visited_item_id, &url))
-      return url.spec();
+  InstantRestrictedID restricted_id = 0;
+  DCHECK_EQ(sizeof(InstantRestrictedID), sizeof(int));
+  if (base::StringToInt(path, &restricted_id)) {
+    InstantMostVisitedItem item;
+    if (instant_service->GetMostVisitedItemForID(restricted_id, &item))
+      return item.url.spec();
   }
   return path;
 }
 
 const std::string InstantService::MaybeTranslateInstantPathOnIO(
     const net::URLRequest* request, const std::string& path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  uint64 most_visited_item_id = 0;
-  if (base::StringToUint64(path, &most_visited_item_id)) {
+
+  InstantRestrictedID restricted_id = 0;
+  DCHECK_EQ(sizeof(InstantRestrictedID), sizeof(int));
+  if (base::StringToInt(path, &restricted_id)) {
     GURL url;
-    if (InstantIOContext::GetURLForMostVisitedItemId(request,
-                                                     most_visited_item_id,
-                                                     &url))
+    if (InstantIOContext::GetURLForMostVisitedItemID(request,
+                                                     restricted_id,
+                                                     &url)) {
       return url.spec();
+    }
   }
   return path;
 }
 
 // static
 bool InstantService::IsInstantPath(const GURL& url) {
   // Strip leading slash.
   std::string path = url.path().substr(1);
 
   // Check that path is of Most Visited item ID form.
   uint64 dummy = 0;
   return base::StringToUint64(path, &dummy);

[palmer, 2013/03/21 22:58:04]

This code should be updated too. We could end up with a URL that passes this
test yet which cannot be parsed as a true instant URL, because
base::StringToUint64 handles a different range than base::StringToInt.

[Shishir, 2013/03/21 23:38:41]

Done.

 }
 
 void InstantService::AddInstantProcess(int process_id) {
   process_ids_.insert(process_id);
 
   if (instant_io_context_) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&InstantIOContext::AddInstantProcessOnIO,
                    instant_io_context_, process_id));
   }
 }
 
 bool InstantService::IsInstantProcess(int process_id) const {
   return process_ids_.find(process_id) != process_ids_.end();
 }
 
-uint64 InstantService::AddURL(const GURL& url) {
-  uint64 id = 0;
-  if (GetMostVisitedItemIDForURL(url, &id))
-    return id;
+void InstantService::AddMostVisitedItems(
+    const std::vector<InstantMostVisitedItem>& items) {
+  most_visited_item_cache_.AddItems(items);
 
-  last_most_visited_item_id_++;
-  most_visited_item_id_to_url_map_[last_most_visited_item_id_] = url;
-  url_to_most_visited_item_id_map_[url] = last_most_visited_item_id_;
-
+  // Post task to the IO thread to copy the data.
   if (instant_io_context_) {
+    std::vector<InstantMostVisitedItemIDPair> items;
+    most_visited_item_cache_.GetCurrentItems(&items);
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
-        base::Bind(&InstantIOContext::AddMostVisitedItemIDOnIO,
-                   instant_io_context_, last_most_visited_item_id_, url));
+        base::Bind(&InstantIOContext::AddMostVisitedItemsOnIO,
+                   instant_io_context_,
+                   items));
   }
-
-  return last_most_visited_item_id_;
 }
 
-bool InstantService::GetMostVisitedItemIDForURL(
-    const GURL& url,
-    uint64 *most_visited_item_id) {
-  std::map<GURL, uint64>::iterator it =
-      url_to_most_visited_item_id_map_.find(url);
-  if (it != url_to_most_visited_item_id_map_.end()) {
-    *most_visited_item_id = it->second;
-    return true;
-  }
-  *most_visited_item_id = 0;
-  return false;
+void InstantService::GetCurrentMostVisitedItems(
+    std::vector<InstantMostVisitedItemIDPair>* items) const {
+  most_visited_item_cache_.GetCurrentItems(items);
 }
 
-bool InstantService::GetURLForMostVisitedItemId(uint64 most_visited_item_id,
-                                                GURL* url) {
-  std::map<uint64, GURL>::iterator it =
-      most_visited_item_id_to_url_map_.find(most_visited_item_id);
-  if (it != most_visited_item_id_to_url_map_.end()) {
-    *url = it->second;
-    return true;
-  }
-  *url = GURL();
-  return false;
+bool InstantService::GetMostVisitedItemForID(
+    InstantRestrictedID most_visited_item_id,
+    InstantMostVisitedItem* item) const {
+  return most_visited_item_cache_.GetItemWithRestrictedID(
+      most_visited_item_id, item);
 }
 
 void InstantService::Shutdown() {
   process_ids_.clear();
 
   if (instant_io_context_) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&InstantIOContext::ClearInstantProcessesOnIO,
                    instant_io_context_));
@@ skipping 11 matching lines @@
       process_ids_.erase(process_id);
 
       if (instant_io_context_) {
         BrowserThread::PostTask(
             BrowserThread::IO, FROM_HERE,
             base::Bind(&InstantIOContext::RemoveInstantProcessOnIO,
                        instant_io_context_, process_id));
       }
       break;
     }
-    case chrome::NOTIFICATION_HISTORY_URLS_DELETED: {
-      content::Details<history::URLsDeletedDetails> det(details);
-      std::vector<GURL> deleted_urls;
-      HistoryDetailsToDeletedURLs(*det.ptr(), &deleted_urls);
-
-      std::vector<uint64> deleted_ids;
-      if (det->all_history) {
-        url_to_most_visited_item_id_map_.clear();
-        most_visited_item_id_to_url_map_.clear();
-      } else {
-        DeleteHistoryURLs(deleted_urls, &deleted_ids);
-      }
-
-      if (instant_io_context_) {
-        BrowserThread::PostTask(
-            BrowserThread::IO, FROM_HERE,
-            base::Bind(&InstantIOContext::DeleteMostVisitedURLsOnIO,
-                       instant_io_context_, deleted_ids, det->all_history));
-      }
-      break;
-    }
     default:
       NOTREACHED() << "Unexpected notification type in InstantService.";
   }
 }
-
-void InstantService::DeleteHistoryURLs(const std::vector<GURL>& deleted_urls,
-                                       std::vector<uint64>* deleted_ids) {
-  for (std::vector<GURL>::const_iterator it = deleted_urls.begin();
-       it != deleted_urls.end();
-       ++it) {
-    std::map<GURL, uint64>::iterator item =
-        url_to_most_visited_item_id_map_.find(*it);
-    if (item != url_to_most_visited_item_id_map_.end()) {
-      uint64 most_visited_item_id = item->second;
-      url_to_most_visited_item_id_map_.erase(item);
-      most_visited_item_id_to_url_map_.erase(
-          most_visited_item_id_to_url_map_.find(most_visited_item_id));
-      deleted_ids->push_back(most_visited_item_id);
-    }
-  }
-}