Fix Acid3 Test 48: LINKTEST, Chromium side....

chrome/browser/renderer_host/browser_render_process_host.cc

 // Copyright (c) 2006-2009 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.
 
 // Represents the browser side of the browser <--> renderer communication
 // channel. There will be one RenderProcessHost per renderer process.
 
 #include "chrome/browser/renderer_host/browser_render_process_host.h"
 
 #include "build/build_config.h"
@@ skipping 105 matching lines @@
     CoUninitialize();
 #endif
   }
 
  private:
   std::string channel_id_;
   // Deleted in CleanUp() on the renderer thread, so don't use a smart pointer.
   RenderProcess* render_process_;
 };
 
+
+// Size of the buffer after which individual link updates deemed not warranted
+// and the overall update should be used instead.
+static const unsigned kVisitedLinkBufferThreshold = 50;
+
+// This class manages buffering and sending visited link hashes (fingerprints)
+// to renderer based on widget visibility.
+// As opposed to the VisitedLinkEventListener in profile.cc, which coalesces to
+// reduce the rate of messages being send to render processes, this class
+// ensures that the updates occur only when explicitly requested. This is
+// used by BrowserRenderProcessHost to only send Add/Reset link events to the
+// renderers when their tabs are visible.
+class VisitedLinkUpdater {
+ public:
+  VisitedLinkUpdater() : threshold_reached_(false) {}
+
+  void Buffer(const VisitedLinkCommon::Fingerprints& links) {
+    if (threshold_reached_)
+      return;
+
+    if (pending_.size() + links.size() > kVisitedLinkBufferThreshold) {
+      threshold_reached_ = true;
+      // Once the threshold is reached, there's no need to store pending visited
+      // links.
+      pending_.clear();
+      return;
+    }
+
+    pending_.insert(pending_.end(), links.begin(), links.end());
+  }
+
+  void Clear() {
+    pending_.clear();
+  }
+
+  void Update(IPC::Channel::Sender* sender) {
+    if (threshold_reached_) {
+      sender->Send(new ViewMsg_VisitedLink_Reset());
+      threshold_reached_ = false;
+      return;
+    }
+
+    if (pending_.size() == 0)
+      return;
+
+    sender->Send(new ViewMsg_VisitedLink_Add(pending_));
+
+    pending_.clear();
+  }
+
+ private:
+  bool threshold_reached_;
+  VisitedLinkCommon::Fingerprints pending_;
+};
+
+
 // Used for a View_ID where the renderer has not been attached yet
 const int32 kInvalidViewID = -1;
 
 // Get the path to the renderer executable, which is the same as the
 // current executable.
 bool GetRendererPath(std::wstring* cmd_line) {
   return PathService::Get(base::FILE_EXE, cmd_line);
 }
 
 BrowserRenderProcessHost::BrowserRenderProcessHost(Profile* profile)
@@ skipping 12 matching lines @@
   if (run_renderer_in_process()) {
     // We need a "renderer pid", but we don't have one when there's no renderer
     // process.  So pick a value that won't clash with other child process pids.
     // Linux has PID_MAX_LIMIT which is 2^22.  Windows always uses pids that are
     // divisible by 4.  So...
     static int next_pid = 4 * 1024 * 1024;
     next_pid += 3;
     SetProcessID(next_pid);
   }
 
+  visited_link_updater_.reset(new VisitedLinkUpdater());
+
   // Note: When we create the BrowserRenderProcessHost, it's technically
   //       backgrounded, because it has no visible listeners.  But the process
   //       doesn't actually exist yet, so we'll Background it later, after
   //       creation.
 }
 
 BrowserRenderProcessHost::~BrowserRenderProcessHost() {
   if (pid() >= 0) {
     WebCacheManager::GetInstance()->Remove(pid());
     ChildProcessSecurityPolicy::GetInstance()->Remove(pid());
@@ skipping 281 matching lines @@
 }
 
 void BrowserRenderProcessHost::ReceivedBadMessage(uint16 msg_type) {
   BadMessageTerminateProcess(msg_type, process_.handle());
 }
 
 void BrowserRenderProcessHost::WidgetRestored() {
   // Verify we were properly backgrounded.
   DCHECK(backgrounded_ == (visible_widgets_ == 0));
   visible_widgets_++;
+  visited_link_updater_->Update(this);
   SetBackgrounded(false);
 }
 
 void BrowserRenderProcessHost::WidgetHidden() {
   // On startup, the browser will call Hide
   if (backgrounded_)
     return;
 
   DCHECK(backgrounded_ == (visible_widgets_ == 0));
   visible_widgets_--;
@@ skipping 11 matching lines @@
   NOTIMPLEMENTED();
 #else
   base::Thread* io_thread = g_browser_process->io_thread();
   if (profile()->GetSpellChecker()) {
     io_thread->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
         profile()->GetSpellChecker(), &SpellChecker::AddWord, word));
   }
 #endif // !defined(OS_WIN)
 }
 
+void BrowserRenderProcessHost::AddVisitedLinks(
+    const VisitedLinkCommon::Fingerprints& links) {
+  visited_link_updater_->Buffer(links);
+  if (visible_widgets_ == 0)
+    return;
+
+  visited_link_updater_->Update(this);
+}
+
+void BrowserRenderProcessHost::ResetVisitedLinks() {
+  visited_link_updater_->Clear();
+  Send(new ViewMsg_VisitedLink_Reset());
+}
+
 base::ProcessHandle BrowserRenderProcessHost::GetRendererProcessHandle() {
   if (run_renderer_in_process())
     return base::Process::Current().handle();
   return process_.handle();
 }
 
 void BrowserRenderProcessHost::InitVisitedLinks() {
   VisitedLinkMaster* visitedlink_master = profile()->GetVisitedLinkMaster();
   if (!visitedlink_master) {
     return;
@@ skipping 396 matching lines @@
 void BrowserRenderProcessHost::OnExtensionRemoveListener(
     const std::string& event_name) {
   ExtensionMessageService::GetInstance(profile()->GetRequestContext())->
       RemoveEventListener(event_name, pid());
 }
 
 void BrowserRenderProcessHost::OnExtensionCloseChannel(int port_id) {
   ExtensionMessageService::GetInstance(profile()->GetRequestContext())->
       CloseChannel(port_id);
 }