chrome/browser/extensions/extension_tab_util_athena.cc

   1 // Copyright (c) 2012 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 "chrome/browser/extensions/extension_tab_util.h"
   6
   7 #include "base/logging.h"
   8 #include "base/values.h"
   9 #include "chrome/browser/extensions/api/tabs/tabs_constants.h"
  10 #include "url/gurl.h"
  11
  12 using content::WebContents;
  13
  14 namespace extensions {
  15
  16 namespace keys = tabs_constants;
  17
  18 ExtensionTabUtil::OpenTabParams::OpenTabParams()
  19     : create_browser_if_needed(false) {
  20 }
  21
  22 ExtensionTabUtil::OpenTabParams::~OpenTabParams() {
  23 }
  24
  25 // Opens a new tab for a given extension. Returns NULL and sets |error| if an
  26 // error occurs.
  27 base::DictionaryValue* ExtensionTabUtil::OpenTab(
  28     ChromeUIThreadExtensionFunction* function,
  29     const OpenTabParams& params,
  30     std::string* error) {
  31   NOTIMPLEMENTED();
  32   return NULL;
  33 }
  34
  35 Browser* ExtensionTabUtil::GetBrowserFromWindowID(
  36     ChromeUIThreadExtensionFunction* function,
  37     int window_id,
  38     std::string* error) {
  39   NOTREACHED();
  40   return NULL;
  41 }
  42
  43 Browser* ExtensionTabUtil::GetBrowserFromWindowID(
  44     const ChromeExtensionFunctionDetails& details,
  45     int window_id,
  46     std::string* error) {
  47   NOTREACHED();
  48   return NULL;
  49 }
  50
  51 int ExtensionTabUtil::GetWindowId(const Browser* browser) {
  52   NOTREACHED();
  53   return -1;
  54 }
  55
  56 int ExtensionTabUtil::GetWindowIdOfTabStripModel(
  57     const TabStripModel* tab_strip_model) {
  58   NOTREACHED();
  59   return -1;
  60 }
  61
  62 int ExtensionTabUtil::GetTabId(const WebContents* web_contents) {
  63   NOTIMPLEMENTED();
  64   return -1;
  65 }
  66
  67 std::string ExtensionTabUtil::GetTabStatusText(bool is_loading) {
  68   NOTIMPLEMENTED();
  69   return keys::kStatusValueComplete;
  70 }
  71
  72 int ExtensionTabUtil::GetWindowIdOfTab(const WebContents* web_contents) {
  73   NOTIMPLEMENTED();
  74   return -1;
  75 }
  76
  77 base::DictionaryValue* ExtensionTabUtil::CreateTabValue(
  78     WebContents* contents,
  79     TabStripModel* tab_strip,
  80     int tab_index,
  81     const Extension* extension) {
  82   NOTREACHED();
  83   return NULL;
  84 }
  85
  86 base::ListValue* ExtensionTabUtil::CreateTabList(
  87     const Browser* browser,
  88     const Extension* extension) {
  89   return new base::ListValue();
  90 }
  91
  92 base::DictionaryValue* ExtensionTabUtil::CreateTabValue(
  93     WebContents* contents,
  94     TabStripModel* tab_strip,
  95     int tab_index) {
  96   NOTREACHED();
  97   return NULL;
  98 }
  99
 100 void ExtensionTabUtil::ScrubTabValueForExtension(
 101     WebContents* contents,
 102     const Extension* extension,
 103     base::DictionaryValue* tab_info) {
 104   // TODO(oshima): Move this to common impl.
 105 }
 106
 107 void ExtensionTabUtil::ScrubTabForExtension(const Extension* extension,
 108                                             api::tabs::Tab* tab) {
 109
 110   // TODO(oshima): Move this to common impl.
 111 }
 112
 113 bool ExtensionTabUtil::GetTabStripModel(const WebContents* web_contents,
 114                                         TabStripModel** tab_strip_model,
 115                                         int* tab_index) {
 116   NOTIMPLEMENTED();
 117   return false;
 118 }
 119
 120 bool ExtensionTabUtil::GetDefaultTab(Browser* browser,
 121                                      WebContents** contents,
 122                                      int* tab_id) {
 123   NOTREACHED();
 124   return false;
 125 }
 126
 127 bool ExtensionTabUtil::GetTabById(int tab_id,
 128                                   content::BrowserContext* browser_context,
 129                                   bool include_incognito,
 130                                   Browser** browser,
 131                                   TabStripModel** tab_strip,
 132                                   WebContents** contents,
 133                                   int* tab_index) {
 134   NOTREACHED();  return false;
 135 }
 136
 137 GURL ExtensionTabUtil::ResolvePossiblyRelativeURL(const std::string& url_string,
 138                                                   const Extension* extension) {
 139   // TODO(oshima): Move this to common impl.
 140   return GURL(url_string);
 141 }
 142
 143 bool ExtensionTabUtil::IsCrashURL(const GURL& url) {
 144   // TODO(oshima): Move this to common impl.
 145   return false;
 146 }
 147
 148 void ExtensionTabUtil::CreateTab(WebContents* web_contents,
 149                                  const std::string& extension_id,
 150                                  WindowOpenDisposition disposition,
 151                                  const gfx::Rect& initial_pos,
 152                                  bool user_gesture) {
 153   NOTIMPLEMENTED();
 154 }
 155
 156 // static
 157 void ExtensionTabUtil::ForEachTab(
 158     const base::Callback<void(WebContents*)>& callback) {
 159   // TODO(oshima): Move this to common impl.
 160 }
 161
 162 // static
 163 WindowController* ExtensionTabUtil::GetWindowControllerOfTab(
 164     const WebContents* web_contents) {
 165   NOTIMPLEMENTED();
 166   return NULL;
 167 }
 168
 169 void ExtensionTabUtil::OpenOptionsPage(const Extension* extension,
 170                                        Browser* browser) {
 171   // NOTIMPLEMENTED();
 172 }
 173
 174 }  // namespace extensions