Rename WebContentsScreenshotManager to NavigationEntryScreenshotManager.

content/browser/frame_host/navigation_entry_screenshot_manager.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 "content/browser/frame_host/web_contents_screenshot_manager.h"
+#include "content/browser/frame_host/navigation_entry_screenshot_manager.h"
 
 #include "base/command_line.h"
 #include "base/threading/worker_pool.h"
 #include "content/browser/frame_host/navigation_controller_impl.h"
 #include "content/browser/frame_host/navigation_entry_impl.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/common/content_switches.h"
 #include "ui/gfx/codec/png_codec.h"
@@ skipping 35 matching lines @@
     std::vector<unsigned char> data;
     if (gfx::PNGCodec::EncodeBGRASkBitmap(bitmap, true, &data))
       data_ = new base::RefCountedBytes(data);
   }
 
   scoped_refptr<base::RefCountedBytes> data_;
 
   DISALLOW_COPY_AND_ASSIGN(ScreenshotData);
 };
 
-WebContentsScreenshotManager::WebContentsScreenshotManager(
+NavigationEntryScreenshotManager::NavigationEntryScreenshotManager(
     NavigationControllerImpl* owner)
     : owner_(owner),
       screenshot_factory_(this),
       min_screenshot_interval_ms_(kMinScreenshotIntervalMS) {
 }
 
-WebContentsScreenshotManager::~WebContentsScreenshotManager() {
+NavigationEntryScreenshotManager::~NavigationEntryScreenshotManager() {
 }
 
-void WebContentsScreenshotManager::TakeScreenshot() {
+void NavigationEntryScreenshotManager::TakeScreenshot() {
   static bool overscroll_enabled = CommandLine::ForCurrentProcess()->
       GetSwitchValueASCII(switches::kOverscrollHistoryNavigation) != "0";
   if (!overscroll_enabled)
     return;
 
   NavigationEntryImpl* entry =
       NavigationEntryImpl::FromNavigationEntry(owner_->GetLastCommittedEntry());
   if (!entry)
     return;
 
@@ skipping 14 matching lines @@
     return;
   }
 
   last_screenshot_time_ = now;
 
   TakeScreenshotImpl(render_view_host, entry);
 }
 
 // Implemented here and not in NavigationEntry because this manager keeps track
 // of the total number of screen shots across all entries.
-void WebContentsScreenshotManager::ClearAllScreenshots() {
+void NavigationEntryScreenshotManager::ClearAllScreenshots() {
   int count = owner_->GetEntryCount();
   for (int i = 0; i < count; ++i) {
     ClearScreenshot(NavigationEntryImpl::FromNavigationEntry(
         owner_->GetEntryAtIndex(i)));
   }
   DCHECK_EQ(GetScreenshotCount(), 0);
 }
 
-void WebContentsScreenshotManager::TakeScreenshotImpl(
+void NavigationEntryScreenshotManager::TakeScreenshotImpl(
     RenderViewHost* host,
     NavigationEntryImpl* entry) {
   DCHECK(host && host->GetView());
   DCHECK(entry);
   host->CopyFromBackingStore(gfx::Rect(),
       host->GetView()->GetViewBounds().size(),
-      base::Bind(&WebContentsScreenshotManager::OnScreenshotTaken,
+      base::Bind(&NavigationEntryScreenshotManager::OnScreenshotTaken,
                  screenshot_factory_.GetWeakPtr(),
                  entry->GetUniqueID()));
 }
 
-void WebContentsScreenshotManager::SetMinScreenshotIntervalMS(int interval_ms) {
+void NavigationEntryScreenshotManager::SetMinScreenshotIntervalMS(
+    int interval_ms) {
   DCHECK_GE(interval_ms, 0);
   min_screenshot_interval_ms_ = interval_ms;
 }
 
-void WebContentsScreenshotManager::OnScreenshotTaken(int unique_id,
+void NavigationEntryScreenshotManager::OnScreenshotTaken(int unique_id,
                                                      bool success,
                                                      const SkBitmap& bitmap) {
   NavigationEntryImpl* entry = NULL;
   int entry_count = owner_->GetEntryCount();
   for (int i = 0; i < entry_count; ++i) {
     NavigationEntry* iter = owner_->GetEntryAtIndex(i);
     if (iter->GetUniqueID() == unique_id) {
       entry = NavigationEntryImpl::FromNavigationEntry(iter);
       break;
     }
   }
 
   if (!entry) {
     LOG(ERROR) << "Invalid entry with unique id: " << unique_id;
     return;
   }
 
   if (!success || bitmap.empty() || bitmap.isNull()) {
     if (!ClearScreenshot(entry))
       OnScreenshotSet(entry);
     return;
   }
 
   scoped_refptr<ScreenshotData> screenshot = new ScreenshotData();
   screenshot->EncodeScreenshot(
       bitmap,
-      base::Bind(&WebContentsScreenshotManager::OnScreenshotEncodeComplete,
+      base::Bind(&NavigationEntryScreenshotManager::OnScreenshotEncodeComplete,
                  screenshot_factory_.GetWeakPtr(),
                  unique_id,
                  screenshot));
 }
 
-int WebContentsScreenshotManager::GetScreenshotCount() const {
+int NavigationEntryScreenshotManager::GetScreenshotCount() const {
   int screenshot_count = 0;
   int entry_count = owner_->GetEntryCount();
   for (int i = 0; i < entry_count; ++i) {
     NavigationEntryImpl* entry =
         NavigationEntryImpl::FromNavigationEntry(owner_->GetEntryAtIndex(i));
     if (entry->screenshot().get())
       screenshot_count++;
   }
   return screenshot_count;
 }
 
-void WebContentsScreenshotManager::OnScreenshotEncodeComplete(
+void NavigationEntryScreenshotManager::OnScreenshotEncodeComplete(
     int unique_id,
     scoped_refptr<ScreenshotData> screenshot) {
   NavigationEntryImpl* entry = NULL;
   int entry_count = owner_->GetEntryCount();
   for (int i = 0; i < entry_count; ++i) {
     NavigationEntry* iter = owner_->GetEntryAtIndex(i);
     if (iter->GetUniqueID() == unique_id) {
       entry = NavigationEntryImpl::FromNavigationEntry(iter);
       break;
     }
   }
   if (!entry)
     return;
   entry->SetScreenshotPNGData(screenshot->data());
   OnScreenshotSet(entry);
 }
 
-void WebContentsScreenshotManager::OnScreenshotSet(NavigationEntryImpl* entry) {
+void NavigationEntryScreenshotManager::OnScreenshotSet(
+    NavigationEntryImpl* entry) {
   if (entry->screenshot().get())
     PurgeScreenshotsIfNecessary();
 }
 
-bool WebContentsScreenshotManager::ClearScreenshot(NavigationEntryImpl* entry) {
+bool NavigationEntryScreenshotManager::ClearScreenshot(
+    NavigationEntryImpl* entry) {
   if (!entry->screenshot().get())
     return false;
 
   entry->SetScreenshotPNGData(NULL);
   return true;
 }
 
-void WebContentsScreenshotManager::PurgeScreenshotsIfNecessary() {
+void NavigationEntryScreenshotManager::PurgeScreenshotsIfNecessary() {
   // Allow only a certain number of entries to keep screenshots.
   const int kMaxScreenshots = 10;
   int screenshot_count = GetScreenshotCount();
   if (screenshot_count < kMaxScreenshots)
     return;
 
   const int current = owner_->GetCurrentEntryIndex();
   const int num_entries = owner_->GetEntryCount();
   int available_slots = kMaxScreenshots;
   if (NavigationEntryImpl::FromNavigationEntry(owner_->GetEntryAtIndex(current))
@@ skipping 45 matching lines @@
         owner_->GetEntryAtIndex(forward));
     if (ClearScreenshot(entry))
       --screenshot_count;
     ++forward;
   }
   CHECK_GE(screenshot_count, 0);
   CHECK_LE(screenshot_count, kMaxScreenshots);
 }
 
 }  // namespace content