MacViews: Allows the toolkit-views Zoom Dialog to be used

chrome/browser/ui/cocoa/location_bar/zoom_decoration.mm

 // 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.
 
 #import "chrome/browser/ui/cocoa/location_bar/zoom_decoration.h"
 
 #include "base/i18n/number_formatting.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/app/vector_icons/vector_icons.h"
+#include "chrome/browser/ui/browser_dialogs.h"
+#import "chrome/browser/ui/cocoa/browser_window_controller.h"
 #import "chrome/browser/ui/cocoa/l10n_util.h"
 #import "chrome/browser/ui/cocoa/location_bar/autocomplete_text_field.h"
 #import "chrome/browser/ui/cocoa/location_bar/autocomplete_text_field_cell.h"
 #import "chrome/browser/ui/cocoa/location_bar/location_bar_view_mac.h"
 #import "chrome/browser/ui/cocoa/omnibox/omnibox_view_mac.h"
 #include "chrome/grit/generated_resources.h"
 #include "chrome/grit/theme_resources.h"
 #include "components/zoom/zoom_controller.h"
 #include "ui/base/cocoa/cocoa_base_utils.h"
 #include "ui/base/l10n/l10n_util_mac.h"
+#include "ui/base/material_design/material_design_controller.h"
+#import "ui/gfx/mac/coordinate_conversion.h"
 
 ZoomDecoration::ZoomDecoration(LocationBarViewMac* owner)
     : owner_(owner), bubble_(nullptr), vector_icon_(nullptr) {}
 
 ZoomDecoration::~ZoomDecoration() {
+  if (ui::MaterialDesignController::IsSecondaryUiMaterial()) {
+    CloseBubble();
+    return;
+  }
   [bubble_ closeWithoutAnimation];
   bubble_.delegate = nil;
 }
 
 bool ZoomDecoration::UpdateIfNecessary(zoom::ZoomController* zoom_controller,
                                        bool default_zoom_changed,
                                        bool location_bar_is_dark) {
   if (!ShouldShowDecoration()) {
-    if (!IsVisible() && !bubble_)
+    if (!IsVisible() && !IsBubbleShown())
       return false;
 
     HideUI();
     return true;
   }
 
   BOOL old_visibility = IsVisible();
   SetVisible(ShouldShowDecoration() && !zoom_controller->IsAtDefaultZoom());
 
   base::string16 zoom_percent =
@@ skipping 24 matching lines @@
 
   content::WebContents* web_contents = owner_->GetWebContents();
   if (!web_contents)
     return;
 
   // Get the frame of the decoration.
   AutocompleteTextField* field = owner_->GetAutocompleteTextField();
   const NSRect frame =
       [[field cell] frameForDecoration:this inFrame:[field bounds]];
 
+  if (ui::MaterialDesignController::IsSecondaryUiMaterial()) {
+    NSWindow* window = [web_contents->GetNativeView() window];
+    if (!window) {
+      // The tab isn't active right now.
+      return;
+    }
+    BrowserWindowController* bwc =

[msw, 2017/04/24 18:53:38]

nit: avoid acronym identifiers.

[varkha, 2017/04/26 04:52:59]

Done.

+        [BrowserWindowController browserWindowControllerForWindow:window];
+    NSPoint anchor = [bwc bookmarkBubblePoint];

[msw, 2017/04/24 18:53:38]

Why show this at the bookmark bubble point? Don't we still show the zoom icon?
Can we re-use the |NSPoint anchor| and GetBubblePointInFrame below? 

[varkha, 2017/04/26 04:52:59]

My guess is that this is called bookmark bubble point because the bookmark
bubble was the first one converted. The anchoring alignment is now same for all
the bubbles (the right edge of the location bar) so the name probably needs to
be updated. I will discuss with tapted@ what name would be good for this, maybe
locationBarBubblePoint or something like that.

GetBubblePointInFrame is a bubble-specific override and should go away after MD
is default - we should not need per-dialog override. I'd rather not prolong its
use here since we no longer anchor to a specific point in the specific icon.

+    gfx::Point anchor_point = gfx::ScreenPointFromNSPoint(
+        ui::ConvertPointFromWindowToScreen(window, anchor));
+    chrome::ShowZoomBubbleViewsAtPoint(web_contents, anchor_point,
+                                       auto_close == NO /* user_action */);
+    return;
+  }
+
   // Find point for bubble's arrow in screen coordinates.
   NSPoint anchor = GetBubblePointInFrame(frame);
   anchor = [field convertPoint:anchor toView:nil];
   anchor = ui::ConvertPointFromWindowToScreen([field window], anchor);
 
   bubble_ = [[ZoomBubbleController alloc] initWithParentWindow:[field window]
                                                       delegate:this];
   [bubble_ showAnchoredAt:anchor autoClose:auto_close];
 }
 
 void ZoomDecoration::CloseBubble() {
+  if (ui::MaterialDesignController::IsSecondaryUiMaterial()) {
+    chrome::CloseZoomBubbleViews();
+    return;
+  }
   [bubble_ close];
 }
 
 void ZoomDecoration::HideUI() {
-  [bubble_ close];
+  CloseBubble();
   SetVisible(false);
 }
 
 void ZoomDecoration::UpdateUI(zoom::ZoomController* zoom_controller,
                               NSString* tooltip_string,
                               bool location_bar_is_dark) {
   vector_icon_ = nullptr;
   zoom::ZoomController::RelativeZoom relative_zoom =
       zoom_controller->GetZoomRelativeToDefault();
   // There is no icon at the default zoom factor.
   if (relative_zoom == zoom::ZoomController::ZOOM_BELOW_DEFAULT_ZOOM) {
     vector_icon_ = &kZoomMinusIcon;
   } else if (relative_zoom == zoom::ZoomController::ZOOM_ABOVE_DEFAULT_ZOOM) {
     vector_icon_ = &kZoomPlusIcon;
   }
 
   SetImage(GetMaterialIcon(location_bar_is_dark));
 
   tooltip_.reset([tooltip_string retain]);
 
-  [bubble_ onZoomChanged];
+  if (ui::MaterialDesignController::IsSecondaryUiMaterial())
+    chrome::RefreshZoomBubbleViews();
+  else
+    [bubble_ onZoomChanged];
 }
 
 NSPoint ZoomDecoration::GetBubblePointInFrame(NSRect frame) {
   return NSMakePoint(cocoa_l10n_util::ShouldDoExperimentalRTLLayout()
                          ? NSMinX(frame)
                          : NSMaxX(frame),
                      NSMaxY(frame));
 }
 
 bool ZoomDecoration::IsAtDefaultZoom() const {
   content::WebContents* web_contents = owner_->GetWebContents();
   if (!web_contents)
     return false;
 
   zoom::ZoomController* zoomController =
       zoom::ZoomController::FromWebContents(web_contents);
   return zoomController && zoomController->IsAtDefaultZoom();
 }
 
+bool ZoomDecoration::IsBubbleShown() const {
+  return (ui::MaterialDesignController::IsSecondaryUiMaterial() &&
+          chrome::IsZoomBubbleViewsShown()) ||
+         bubble_;
+}
+
 bool ZoomDecoration::ShouldShowDecoration() const {
   return owner_->GetWebContents() != NULL &&
-      !owner_->GetToolbarModel()->input_in_progress() &&
-      (bubble_ || !IsAtDefaultZoom());
+         !owner_->GetToolbarModel()->input_in_progress() &&
+         (IsBubbleShown() || !IsAtDefaultZoom());
 }
 
 bool ZoomDecoration::AcceptsMousePress() {
   return true;
 }
 
 bool ZoomDecoration::OnMousePressed(NSRect frame, NSPoint location) {
-  if (bubble_)
+  if (IsBubbleShown()) {
     CloseBubble();
-  else
-    ShowBubble(YES);
+  } else {
+    BOOL auto_close = !ui::MaterialDesignController::IsSecondaryUiMaterial();

[varkha, 2017/04/24 12:59:37]

Note: prefer this to inlining for being self-documenting.
self review - const.

[msw, 2017/04/24 18:53:38]

Why would we change the auto-close behavior depending on MD/views?

[varkha, 2017/04/26 04:52:59]

I don't think this should be any different from other platforms when the views
implementation becomes default. Other platforms don't auto-close the bubble when
it is opened by a click. See also http://crbug/177940 . I've added a comment
now, but it should probably go away together with that variable and we should
just do ShowBubble(true /*user_action */) in the end.

+    ShowBubble(auto_close);
+  }
   return true;
 }
 
 NSString* ZoomDecoration::GetToolTip() {
   return tooltip_.get();
 }
 
 content::WebContents* ZoomDecoration::GetWebContents() {
   return owner_->GetWebContents();
 }
 
 void ZoomDecoration::OnClose() {
-  bubble_.delegate = nil;
-  bubble_ = nil;
+  if (!ui::MaterialDesignController::IsSecondaryUiMaterial()) {
+    bubble_.delegate = nil;
+    bubble_ = nil;
+  }
 
   // If the page is at default zoom then hiding the zoom decoration
   // was suppressed while the bubble was open. Now that the bubble is
   // closed the decoration can be hidden.
   if (IsAtDefaultZoom() && IsVisible()) {
     SetVisible(false);
     owner_->OnDecorationsChanged();
   }
 }
 
 const gfx::VectorIcon* ZoomDecoration::GetMaterialVectorIcon() const {
   return vector_icon_;
 }