Mac: Content blocked icons.

chrome/browser/cocoa/location_bar_view_mac.mm

 // Copyright (c) 2010 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.
 
 #import "chrome/browser/cocoa/location_bar_view_mac.h"
 
 #include "app/l10n_util_mac.h"
 #include "app/resource_bundle.h"
+#include "base/nsimage_cache_mac.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "base/sys_string_conversions.h"
 #include "chrome/app/chrome_dll_resource.h"
 #include "chrome/browser/alternate_nav_url_fetcher.h"
 #import "chrome/browser/app_controller_mac.h"
 #import "chrome/browser/autocomplete/autocomplete_edit_view_mac.h"
 #include "chrome/browser/browser_list.h"
 #import "chrome/browser/cocoa/autocomplete_text_field.h"
 #import "chrome/browser/cocoa/autocomplete_text_field_cell.h"
 #include "chrome/browser/cocoa/event_utils.h"
+#import "chrome/browser/cocoa/extensions/extension_action_context_menu.h"
 #import "chrome/browser/cocoa/extensions/extension_popup_controller.h"
 #include "chrome/browser/command_updater.h"
 #include "chrome/browser/extensions/extension_browser_event_router.h"
 #include "chrome/browser/extensions/extensions_service.h"
 #include "chrome/browser/extensions/extension_tabs_module.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/search_engines/template_url_model.h"
 #include "chrome/browser/tab_contents/navigation_entry.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
@@ skipping 62 matching lines @@
           toolbar_model, profile, command_updater, field)),
       command_updater_(command_updater),
       field_(field),
       disposition_(CURRENT_TAB),
       security_image_view_(this, profile, toolbar_model),
       page_action_views_(this, profile, toolbar_model),
       profile_(profile),
       browser_(browser),
       toolbar_model_(toolbar_model),
       transition_(PageTransition::TYPED) {
+  for (int i = 0; i < CONTENT_SETTINGS_NUM_TYPES; ++i) {
+    ContentBlockedImageView* content_blocked_view =
+        new ContentBlockedImageView(static_cast<ContentSettingsType>(i), this,
+                                    profile_);
+    content_blocked_views_.push_back(content_blocked_view);
+    content_blocked_view->SetVisible(false);
+  }
+
   AutocompleteTextFieldCell* cell = [field_ autocompleteTextFieldCell];
   [cell setSecurityImageView:&security_image_view_];
   [cell setPageActionViewList:&page_action_views_];
+  [cell setContentBlockedViewList:&content_blocked_views_];
 
   registrar_.Add(this,
       NotificationType::EXTENSION_PAGE_ACTION_VISIBILITY_CHANGED,
       NotificationService::AllSources());
 }
 
 LocationBarViewMac::~LocationBarViewMac() {
   // Disconnect from cell in case it outlives us.
   AutocompleteTextFieldCell* cell = [field_ autocompleteTextFieldCell];
   [cell setPageActionViewList:NULL];
   [cell setSecurityImageView:NULL];
 }
 
 std::wstring LocationBarViewMac::GetInputString() const {
   return location_input_;
 }
 
 WindowOpenDisposition LocationBarViewMac::GetWindowOpenDisposition() const {
   return disposition_;
 }
 
+// TODO(thakis): Ping shess to verify what he wants to verify.
 // TODO(shess): Verify that this TODO is TODONE.
 // TODO(rohitrao): Fix this to return different types once autocomplete and
 // the onmibar are implemented.  For now, any URL that comes from the
 // LocationBar has to have been entered by the user, and thus is of type
 // PageTransition::TYPED.
 PageTransition::Type LocationBarViewMac::GetPageTransition() const {
   return transition_;
 }
 
 void LocationBarViewMac::AcceptInput() {
   WindowOpenDisposition disposition =
       event_utils::WindowOpenDispositionFromNSEvent([NSApp currentEvent]);
   AcceptInputWithDisposition(disposition);
 }
 
 void LocationBarViewMac::AcceptInputWithDisposition(
     WindowOpenDisposition disposition) {
   edit_view_->model()->AcceptInput(disposition, false);
 }
 
 void LocationBarViewMac::FocusLocation() {
   edit_view_->FocusLocation();
 }
 
 void LocationBarViewMac::FocusSearch() {
   edit_view_->SetForcedQuery();
 }
 
 void LocationBarViewMac::UpdateContentBlockedIcons() {
-  // TODO(pkasting): Implement.
+  RefreshContentBlockedViews();
+  [field_ updateCursorAndToolTipRects];
+  [field_ setNeedsDisplay:YES];
 }
 
 void LocationBarViewMac::UpdatePageActions() {
   size_t count_before = page_action_views_.Count();
   page_action_views_.RefreshViews();
   [field_ resetFieldEditorFrameIfNeeded];
   if (page_action_views_.Count() != count_before) {
     NotificationService::current()->Notify(
         NotificationType::EXTENSION_PAGE_ACTION_COUNT_CHANGED,
         Source<LocationBar>(this),
@@ skipping 14 matching lines @@
 
 void LocationBarViewMac::SaveStateToContents(TabContents* contents) {
   // TODO(shess): Why SaveStateToContents vs SaveStateToTab?
   edit_view_->SaveStateToTab(contents);
 }
 
 void LocationBarViewMac::Update(const TabContents* contents,
                                 bool should_restore_state) {
   SetSecurityIcon(toolbar_model_->GetIcon());
   page_action_views_.RefreshViews();
+  RefreshContentBlockedViews();
   // AutocompleteEditView restores state if the tab is non-NULL.
   edit_view_->Update(should_restore_state ? contents : NULL);
 }
 
 void LocationBarViewMac::OnAutocompleteAccept(const GURL& url,
                                               WindowOpenDisposition disposition,
                                               PageTransition::Type transition,
                                               const GURL& alternate_nav_url) {
   if (!url.is_valid())
     return;
@@ skipping 290 matching lines @@
       NOTREACHED() << "Unexpected notification";
       break;
   }
 }
 
 void LocationBarViewMac::PostNotification(const NSString* notification) {
   [[NSNotificationCenter defaultCenter] postNotificationName:notification
                                         object:[NSValue valueWithPointer:this]];
 }
 
+void LocationBarViewMac::RefreshContentBlockedViews() {
+  const TabContents* tab_contents = browser_->GetSelectedTabContents();
+  for (ContentBlockedViews::iterator it(content_blocked_views_.begin());
+      it != content_blocked_views_.end();
+      ++it) {
+    (*it)->SetVisible((!toolbar_model_->input_in_progress() && tab_contents) ?
+        tab_contents->IsContentBlocked((*it)->settings_type()) : false);
+  }
+}
+
 // LocationBarImageView---------------------------------------------------------
 
 void LocationBarViewMac::LocationBarImageView::SetImage(NSImage* image) {
   image_.reset([image retain]);
 }
 
 void LocationBarViewMac::LocationBarImageView::SetImage(SkBitmap* image) {
   SetImage(gfx::SkBitmapToNSImage(*image));
 }
 
@@ skipping 51 matching lines @@
         warning_icon_.reset([rb.GetNSImageNamed(IDR_WARNING) retain]);
       }
       SetImage(warning_icon_);
       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
-bool LocationBarViewMac::SecurityImageView::OnMousePressed() {
+void LocationBarViewMac::SecurityImageView::OnMousePressed(NSRect bounds) {
   TabContents* tab = owner_->GetTabContents();
   NavigationEntry* nav_entry = tab->controller().GetActiveEntry();
   if (!nav_entry) {
     NOTREACHED();
-    return true;
+    return;
   }
   tab->ShowPageInfo(nav_entry->url(), nav_entry->ssl(), true);
-  return true;
 }
 
 // PageActionImageView----------------------------------------------------------
 
 LocationBarViewMac::PageActionImageView::PageActionImageView(
     LocationBarViewMac* owner,
     Profile* profile,
     ExtensionAction* page_action)
     : owner_(owner),
       profile_(profile),
@@ skipping 35 matching lines @@
   } else if (image) {
     return [image size];
   }
   // Default value for image size is undefined when preview is not enabled.
   NOTREACHED();
   return NSMakeSize(0, 0);
 }
 
 // Overridden from LocationBarImageView. Either notify listeners or show a
 // popup depending on the Page Action.
-bool LocationBarViewMac::PageActionImageView::OnMousePressed(NSRect bounds) {
+void LocationBarViewMac::PageActionImageView::OnMousePressed(NSRect bounds) {
   if (current_tab_id_ < 0) {
     NOTREACHED() << "No current tab.";
     // We don't want other code to try and handle this click.  Returning true
     // prevents this by indicating that we handled it.
-    return true;
+    return;
   }
 
   if (page_action_->HasPopup(current_tab_id_)) {
     AutocompleteTextField* textField = owner_->GetAutocompleteTextField();
     NSWindow* window = [textField window];
     NSRect relativeBounds = [[window contentView] convertRect:bounds
                                                      fromView:textField];
     NSPoint arrowPoint = [window convertBaseToScreen:NSMakePoint(
         NSMinX(relativeBounds),
         NSMinY(relativeBounds))];
 
     // Adjust the anchor point to be at the center of the page action icon.
     arrowPoint.x += [GetImage() size].width / 2;
 
     [ExtensionPopupController showURL:page_action_->GetPopupUrl(current_tab_id_)
                             inBrowser:BrowserList::GetLastActive()
                            anchoredAt:arrowPoint
                         arrowLocation:kTopRight];
   } else {
     ExtensionBrowserEventRouter::GetInstance()->PageActionExecuted(
         profile_, page_action_->extension_id(), page_action_->id(),
         current_tab_id_, current_url_.spec(),
         1);
   }
-  return true;
 }
 
 void LocationBarViewMac::PageActionImageView::OnImageLoaded(SkBitmap* image,
                                                             size_t index) {
   // We loaded icons()->size() icons, plus one extra if the Page Action had
   // a default icon.
   int total_icons = page_action_->icon_paths()->size();
   if (!page_action_->default_icon_path().empty())
     total_icons++;
   DCHECK(static_cast<int>(index) < total_icons);
@@ skipping 80 matching lines @@
     SetToolTip(nil);
     return;
   }
   SetToolTip(base::SysUTF8ToNSString(tooltip));
 }
 
 const NSString* LocationBarViewMac::PageActionImageView::GetToolTip() {
   return tooltip_.get();
 }
 
+NSMenu* LocationBarViewMac::PageActionImageView::GetMenu() {
+  if (!profile_)
+    return nil;
+  ExtensionsService* service = profile_->GetExtensionsService();
+  if (!service)
+    return nil;
+  Extension* extension = service->GetExtensionById(
+      page_action_->extension_id(), false);
+  DCHECK(extension);
+  if (!extension)
+    return nil;
+  return [[[ExtensionActionContextMenu alloc]
+      initWithExtension:extension profile:profile_] autorelease];
+}
+
 void LocationBarViewMac::PageActionImageView::Observe(
     NotificationType type,
     const NotificationSource& source,
     const NotificationDetails& details) {
   switch (type.value) {
     case NotificationType::EXTENSION_HOST_VIEW_SHOULD_CLOSE: {
       ExtensionPopupController* popup = [ExtensionPopupController popup];
       if (popup && ![popup isClosing])
         [popup close];
 
       break;
     }
     default:
       NOTREACHED() << "Unexpected notification";
       break;
   }
 }
 
+// ContentSettingsImageView-----------------------------------------------------
+
+LocationBarViewMac::ContentBlockedImageView::ContentBlockedImageView(
+    ContentSettingsType settings_type,
+    LocationBarViewMac* owner,
+    Profile* profile)
+    : settings_type_(settings_type),
+      owner_(owner),
+      profile_(profile) {
+  // TODO(thakis): We should use pdfs for these icons on OSX.
+  // http://crbug.com/35847
+  static const int kIconIDs[] = {
+    IDR_BLOCKED_COOKIES,
+    IDR_BLOCKED_IMAGES,
+    IDR_BLOCKED_JAVASCRIPT,
+    IDR_BLOCKED_PLUGINS,
+    IDR_BLOCKED_POPUPS,
+  };
+  DCHECK_EQ(arraysize(kIconIDs),
+            static_cast<size_t>(CONTENT_SETTINGS_NUM_TYPES));
+  ResourceBundle& rb = ResourceBundle::GetSharedInstance();
+  SetImage(rb.GetNSImageNamed(kIconIDs[settings_type]));
+
+  static const int kTooltipIDs[] = {
+    IDS_BLOCKED_COOKIES_TITLE,
+    IDS_BLOCKED_IMAGES_TITLE,
+    IDS_BLOCKED_JAVASCRIPT_TITLE,
+    IDS_BLOCKED_PLUGINS_TITLE,
+    IDS_BLOCKED_POPUPS_TOOLTIP,
+  };
+  DCHECK_EQ(arraysize(kTooltipIDs),
+            static_cast<size_t>(CONTENT_SETTINGS_NUM_TYPES));
+  SetToolTip(l10n_util::GetNSStringWithFixup(kTooltipIDs[settings_type]));
+}
+
+LocationBarViewMac::ContentBlockedImageView::~ContentBlockedImageView() {}
+
+void LocationBarViewMac::ContentBlockedImageView::OnMousePressed(NSRect bounds)
+    {
+  // TODO(thakis): Implement.
+  NOTIMPLEMENTED();
+}
+
+const NSString* LocationBarViewMac::ContentBlockedImageView::GetToolTip() {
+  return tooltip_.get();
+}
+
+void LocationBarViewMac::ContentBlockedImageView::SetToolTip(NSString* tooltip)
+    {
+  tooltip_.reset([tooltip retain]);
+}
+
+
 // PageActionViewList-----------------------------------------------------------
 
 void LocationBarViewMac::PageActionViewList::DeleteAll() {
   if (!views_.empty()) {
     STLDeleteContainerPointers(views_.begin(), views_.end());
     views_.clear();
   }
 }
 
 void LocationBarViewMac::PageActionViewList::RefreshViews() {
@@ skipping 49 matching lines @@
       ++result;
   }
   return result;
 }
 
 void LocationBarViewMac::PageActionViewList::OnMousePressed(NSRect iconFrame,
                                                             size_t index) {
   ViewAt(index)->OnMousePressed(iconFrame);
 }