src/chrome/browser/ui/views/settings_api_bubble_helper_views.cc

   1 // Copyright (c) 2014 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/ui/views/settings_api_bubble_helper_views.h"
   6
   7 #include "chrome/browser/extensions/settings_api_bubble_controller.h"
   8 #include "chrome/browser/profiles/profile.h"
   9 #include "chrome/browser/ui/browser.h"
  10 #include "chrome/browser/ui/browser_finder.h"
  11 #include "chrome/browser/ui/views/extensions/extension_message_bubble_view.h"
  12 #include "chrome/browser/ui/views/frame/browser_view.h"
  13 #include "chrome/browser/ui/views/settings_api_bubble_helper_views.h"
  14 #include "chrome/browser/ui/views/toolbar/home_button.h"
  15 #include "chrome/browser/ui/views/toolbar/toolbar_view.h"
  16 #include "chrome/common/extensions/manifest_handlers/settings_overrides_handler.h"
  17 #include "content/public/browser/browser_context.h"
  18 #include "extensions/browser/extension_registry.h"
  19
  20 namespace {
  21
  22 void ShowSettingsApiBubble(extensions::SettingsApiOverrideType type,
  23                            const std::string& extension_id,
  24                            Profile* profile,
  25                            views::View* anchor_view,
  26                            views::BubbleBorder::Arrow arrow) {
  27   scoped_ptr<extensions::SettingsApiBubbleController> settings_api_bubble(
  28       new extensions::SettingsApiBubbleController(profile, type));
  29   if (!settings_api_bubble->ShouldShow(extension_id))
  30     return;
  31
  32   extensions::SettingsApiBubbleController* controller =
  33       settings_api_bubble.get();
  34   extensions::ExtensionMessageBubbleView* bubble_delegate =
  35       new extensions::ExtensionMessageBubbleView(
  36           anchor_view,
  37           arrow,
  38           settings_api_bubble.PassAs<
  39               extensions::ExtensionMessageBubbleController>());
  40   views::BubbleDelegateView::CreateBubble(bubble_delegate);
  41   controller->Show(bubble_delegate);
  42 }
  43
  44 }  // namespace
  45
  46 namespace extensions {
  47
  48 void MaybeShowExtensionControlledHomeNotification(Browser* browser) {
  49 #if !defined(OS_WIN)
  50   return;
  51 #endif
  52
  53   const Extension* extension = OverridesHomepage(browser->profile(), NULL);
  54   if (extension) {
  55     // The bubble will try to anchor itself against the home button
  56     views::View* anchor_view = BrowserView::GetBrowserViewForBrowser(browser)->
  57         toolbar()->home_button();
  58     ShowSettingsApiBubble(BUBBLE_TYPE_HOME_PAGE,
  59                           extension->id(),
  60                           browser->profile(),
  61                           anchor_view,
  62                           views::BubbleBorder::TOP_LEFT);
  63   }
  64 }
  65
  66 void MaybeShowExtensionControlledSearchNotification(
  67     Profile* profile,
  68     content::WebContents* web_contents,
  69     const AutocompleteMatch& match) {
  70 #if !defined(OS_WIN)
  71   return;
  72 #endif
  73
  74   if (match.provider &&
  75       match.provider->type() == AutocompleteProvider::TYPE_SEARCH) {
  76     const extensions::Extension* extension =
  77         OverridesSearchEngine(profile, NULL);
  78     if (extension) {
  79       ToolbarView* toolbar =
  80           BrowserView::GetBrowserViewForBrowser(
  81               chrome::FindBrowserWithWebContents(web_contents))->toolbar();
  82       ShowSettingsApiBubble(BUBBLE_TYPE_SEARCH_ENGINE,
  83                             extension->id(),
  84                             profile,
  85                             toolbar->app_menu(),
  86                             views::BubbleBorder::TOP_RIGHT);
  87     }
  88   }
  89 }
  90
  91 const extensions::SettingsOverrides* FindOverridingExtension(
  92     content::BrowserContext* browser_context,
  93     SettingsApiOverrideType type,
  94     const Extension** extension) {
  95   const extensions::ExtensionSet& extensions =
  96       extensions::ExtensionRegistry::Get(browser_context)->enabled_extensions();
  97
  98   for (extensions::ExtensionSet::const_iterator it = extensions.begin();
  99        it != extensions.end();
 100        ++it) {
 101     const extensions::SettingsOverrides* settings =
 102         extensions::SettingsOverrides::Get(*it);
 103     if (settings) {
 104       if ((type == BUBBLE_TYPE_HOME_PAGE && settings->homepage) ||
 105           (type == BUBBLE_TYPE_STARTUP_PAGES &&
 106               !settings->startup_pages.empty()) ||
 107           (type == BUBBLE_TYPE_SEARCH_ENGINE && settings->search_engine)) {
 108         *extension = *it;
 109         return settings;
 110       }
 111     }
 112   }
 113
 114   return NULL;
 115 }
 116
 117 const Extension* OverridesHomepage(content::BrowserContext* browser_context,
 118                                    GURL* home_page_url) {
 119   const extensions::Extension* extension = NULL;
 120   const extensions::SettingsOverrides* settings =
 121       FindOverridingExtension(
 122           browser_context, BUBBLE_TYPE_HOME_PAGE, &extension);
 123   if (settings && home_page_url)
 124     *home_page_url = *settings->homepage;
 125   return extension;
 126 }
 127
 128 const Extension* OverridesStartupPages(content::BrowserContext* browser_context,
 129                                        std::vector<GURL>* startup_pages) {
 130   const extensions::Extension* extension = NULL;
 131   const extensions::SettingsOverrides* settings =
 132       FindOverridingExtension(
 133           browser_context, BUBBLE_TYPE_STARTUP_PAGES, &extension);
 134   if (settings && startup_pages) {
 135     startup_pages->clear();
 136     for (std::vector<GURL>::const_iterator it = settings->startup_pages.begin();
 137          it != settings->startup_pages.end();
 138          ++it)
 139       startup_pages->push_back(GURL(*it));
 140   }
 141   return extension;
 142 }
 143
 144 const Extension* OverridesSearchEngine(
 145     content::BrowserContext* browser_context,
 146     api::manifest_types::ChromeSettingsOverrides::Search_provider*
 147         search_provider) {
 148   const extensions::Extension* extension = NULL;
 149   const extensions::SettingsOverrides* settings =
 150       FindOverridingExtension(
 151           browser_context, BUBBLE_TYPE_SEARCH_ENGINE, &extension);
 152   if (settings && search_provider)
 153     search_provider = settings->search_engine.get();
 154   return extension;
 155 }
 156
 157 }  // namespace extensions