Move SessionID, CaptureVisibleTabFunction to WebContents.

chrome/browser/extensions/api/tabs/tabs.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 "chrome/browser/extensions/api/tabs/tabs.h"
 
 #include <algorithm>
 #include <limits>
 #include <vector>
 
@@ skipping 1214 matching lines @@
     Browser* browser = GetCurrentBrowser();
     if (!browser) {
       error_ = keys::kNoCurrentWindowError;
       return false;
     }
     contents = browser->tab_strip_model()->GetActiveTabContents();
     if (!contents) {
       error_ = keys::kNoSelectedTabError;
       return false;
     }
-    tab_id = SessionID::IdForTab(contents);
+    tab_id = SessionID::IdForTab(contents->web_contents());
   } else {
     EXTENSION_FUNCTION_VALIDATE(tab_value->GetAsInteger(&tab_id));
   }
 
   int tab_index = -1;
   TabStripModel* tab_strip = NULL;
   if (!GetTabById(tab_id, profile(), include_incognito(),
                   NULL, &tab_strip, &contents, &tab_index, &error_)) {
     return false;
   }
@@ skipping 348 matching lines @@
     }
 
     // There's a chance that the tab is being dragged, or we're in some other
     // nested event loop. This code path ensures that the tab is safely closed
     // under such circumstances, whereas |chrome::CloseWebContents()| does not.
     contents->web_contents()->Close();
   }
   return true;
 }
 
-bool CaptureVisibleTabFunction::GetTabToCapture(
-    WebContents** web_contents, TabContents** tab_contents) {
+bool CaptureVisibleTabFunction::GetTabToCapture(WebContents** web_contents) {
   Browser* browser = NULL;
   // windowId defaults to "current" window.
   int window_id = extension_misc::kCurrentWindowId;
 
   if (HasOptionalArgument(0))
     EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &window_id));
 
   if (!GetBrowserFromWindowID(this, window_id, &browser))
     return false;
 
   *web_contents = chrome::GetActiveWebContents(browser);
   if (*web_contents == NULL) {
     error_ = keys::kInternalVisibleTabCaptureError;
     return false;
   }
 
-  *tab_contents = chrome::GetActiveTabContents(browser);
-
   return true;
 };
 
 bool CaptureVisibleTabFunction::RunImpl() {
   PrefService* service = profile()->GetPrefs();
   if (service->GetBoolean(prefs::kDisableScreenshots)) {
     error_ = keys::kScreenshotsDisabled;
     return false;
   }
 
   WebContents* web_contents = NULL;
-  TabContents* tab_contents = NULL;
-  if (!GetTabToCapture(&web_contents, &tab_contents))
+  if (!GetTabToCapture(&web_contents))
     return false;
 
   image_format_ = FORMAT_JPEG;  // Default format is JPEG.
   image_quality_ = kDefaultQuality;  // Default quality setting.
 
   if (HasOptionalArgument(1)) {
     DictionaryValue* options = NULL;
     EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &options));
 
     if (options->HasKey(keys::kFormatKey)) {
@@ skipping 15 matching lines @@
       EXTENSION_FUNCTION_VALIDATE(
           options->GetInteger(keys::kQualityKey, &image_quality_));
     }
   }
 
   // captureVisibleTab() can return an image containing sensitive information
   // that the browser would otherwise protect.  Ensure the extension has
   // permission to do this.
   if (!GetExtension()->CanCaptureVisiblePage(
         web_contents->GetURL(),
-        SessionID::IdForTab(tab_contents),
+        SessionID::IdForTab(web_contents),
         &error_)) {
     return false;
   }
 
   RenderViewHost* render_view_host = web_contents->GetRenderViewHost();
   content::RenderWidgetHostView* view = render_view_host->GetView();
   if (!view) {
     error_ = keys::kInternalVisibleTabCaptureError;
     return false;
   }
@@ skipping 11 matching lines @@
 void CaptureVisibleTabFunction::CopyFromBackingStoreComplete(
     skia::PlatformCanvas* canvas,
     bool succeeded) {
   if (succeeded) {
     VLOG(1) << "captureVisibleTab() got image from backing store.";
     SendResultFromBitmap(skia::GetTopDevice(*canvas)->accessBitmap(false));
     return;
   }
 
   WebContents* web_contents = NULL;
-  TabContents* tab_contents = NULL;
-  if (!GetTabToCapture(&web_contents, &tab_contents)) {
+  if (!GetTabToCapture(&web_contents)) {
     error_ = keys::kInternalVisibleTabCaptureError;
     SendResponse(false);
     return;
   }
 
   // Ask the renderer for a snapshot of the tab.
   registrar_.Add(this,
                  chrome::NOTIFICATION_TAB_SNAPSHOT_TAKEN,
                  content::Source<WebContents>(web_contents));
   AddRef();  // Balanced in CaptureVisibleTabFunction::Observe().
-  tab_contents->snapshot_tab_helper()->CaptureSnapshot();
+  TabContents::FromWebContents(web_contents)->snapshot_tab_helper()->
+      CaptureSnapshot();
 }
 
 // If a backing store was not available in CaptureVisibleTabFunction::RunImpl,
 // than the renderer was asked for a snapshot.  Listen for a notification
 // that the snapshot is available.
 void CaptureVisibleTabFunction::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK(type == chrome::NOTIFICATION_TAB_SNAPSHOT_TAKEN);
@@ skipping 136 matching lines @@
   // called for every API call the extension made.
   GotLanguage(language);
 }
 
 void DetectTabLanguageFunction::GotLanguage(const std::string& language) {
   SetResult(Value::CreateStringValue(language.c_str()));
   SendResponse(true);
 
   Release();  // Balanced in Run()
 }