Toolbar: Report offline state through icon and verbose text.

chrome/browser/android/vr_shell/textures/url_bar_texture.cc

 // Copyright 2017 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/android/vr_shell/textures/url_bar_texture.h"
 
 #include "base/strings/utf_string_conversions.h"
 #include "cc/paint/skia_paint_canvas.h"
 #include "chrome/browser/android/vr_shell/color_scheme.h"
 #include "chrome/browser/android/vr_shell/textures/render_text_wrapper.h"
@@ skipping 39 matching lines @@
     case SecurityLevel::SECURE_WITH_POLICY_INSTALLED_CERT:  // ChromeOS only.
       return color_scheme.insecure;
     case SecurityLevel::DANGEROUS:
       return color_scheme.insecure;
     default:
       NOTREACHED();
       return color_scheme.insecure;
   }
 }
 
+SkColor GetSecurityChipColor(SecurityLevel level,
+                             bool offline_page,
+                             const ColorScheme& color_scheme) {
+  if (offline_page)
+    return color_scheme.url_emphasized;

[fgorski, 2017/07/06 20:01:33]

per our discussion I am concerned about putting that in black and matching the
color between chip/status and URL

[cjgrant, 2017/07/06 20:13:00]

Noted.  I'll follow up with Josh Carpenter (our UX lead) and rachelis@, but a
color tweak would likely be a follow-on CL.

+  return GetSchemeColor(level, color_scheme);
+}
+
 void setEmphasis(vr_shell::RenderTextWrapper* render_text,
                  bool emphasis,
                  const gfx::Range& range,
                  const ColorScheme& color_scheme) {
   SkColor color =
       emphasis ? color_scheme.url_emphasized : color_scheme.url_deemphasized;
   if (range.IsValid()) {
     render_text->ApplyColor(color, range);
   } else {
     render_text->SetColor(color);
   }
 }
 
 gfx::PointF percentToMeters(const gfx::PointF& percent) {
   return gfx::PointF(percent.x() * kWidth, percent.y() * kHeight);
 }
 
 }  // namespace
 
 UrlBarTexture::UrlBarTexture(
     bool web_vr,
     const base::Callback<void(UiUnsupportedMode)>& failure_callback)
     : has_back_button_(!web_vr),
-      has_security_chip_(false),
       failure_callback_(failure_callback) {}
 
 UrlBarTexture::~UrlBarTexture() = default;
 
 void UrlBarTexture::SetToolbarState(const ToolbarState& state) {
   if (state_ == state)
     return;
   state_ = state;
   set_dirty();
 }
@@ skipping 118 matching lines @@
                                  : color_scheme().disabled);
     canvas->restore();
 
     back_button_hit_region_.SetRect(left_edge, 0, left_edge + kBackButtonWidth,
                                     kHeight);
     left_edge += kBackButtonWidth + kSeparatorWidth;
   }
 
   // Site security state icon.
   left_edge += kFieldSpacing;
-  if (state_.security_level != security_state::NONE &&
-      state_.vector_icon != nullptr) {
+  if ((state_.security_level != security_state::NONE || state_.offline_page) &&
+      state_.vector_icon != nullptr && state_.should_display_url) {
     gfx::RectF icon_region(left_edge, kHeight / 2 - kSecurityIconSize / 2,
                            kSecurityIconSize, kSecurityIconSize);
     canvas->save();
     canvas->translate(icon_region.x(), icon_region.y());
     const gfx::VectorIcon& icon = *state_.vector_icon;
     float icon_scale = kSecurityIconSize / GetDefaultSizeOfVectorIcon(icon);
     canvas->scale(icon_scale, icon_scale);
     PaintVectorIcon(&gfx_canvas, icon,
-                    GetSchemeColor(state_.security_level, color_scheme()));
+                    GetSecurityChipColor(state_.security_level,
+                                         state_.offline_page, color_scheme()));
     canvas->restore();
 
     security_hit_region_ = icon_region;
     left_edge += kSecurityIconSize + kFieldSpacing;
   }
 
   canvas->restore();
 
   // Draw security chip text (eg. "Not secure") next to the security icon.
-  if (has_security_chip_ && state_.should_display_url) {
+  if (state_.offline_page && state_.should_display_url) {

[fgorski, 2017/07/06 20:01:34]

this will only kick in for offline pages if you &&
Is that intentional?

[cjgrant, 2017/07/06 20:13:00]

Yes.  We added chip support for "Secure" and "Not secure", but did not enable
it, because it consumes too much space.  We rely on the red/green scheme and
icon there.  The "Offline" chip is a slightly different thing it looks like, and
hence, I'm activating that dormant chip code only in the offline case.

We might enable the "Not secure" chip for M-62.

     float chip_max_width = kWidth - left_edge - kUrlRightMargin;
     gfx::Rect text_bounds(ToPixels(left_edge), 0, ToPixels(chip_max_width),
                           ToPixels(kHeight));
 
     int pixel_font_height = texture_size.height() * kFontHeight / kHeight;
-    SkColor chip_color = GetSchemeColor(state_.security_level, color_scheme());
+    SkColor chip_color = GetSecurityChipColor(
+        state_.security_level, state_.offline_page, color_scheme());
     const base::string16& chip_text = state_.secure_verbose_text;
     DCHECK(!chip_text.empty());
 
     gfx::FontList font_list;
     if (!GetFontList(pixel_font_height, chip_text, &font_list))
       failure_callback_.Run(UiUnsupportedMode::kUnhandledCodePoint);
 
     std::unique_ptr<gfx::RenderText> render_text(
         gfx::RenderText::CreateInstance());
     render_text->SetFontList(font_list);
@@ skipping 33 matching lines @@
       last_drawn_gurl_ = state_.gurl;
       last_drawn_security_level_ = state_.security_level;
     }
     url_render_text_->Draw(&gfx_canvas);
   }
 }
 
 void UrlBarTexture::RenderUrl(const gfx::Size& texture_size,
                               const gfx::Rect& bounds) {
   url::Parsed parsed;
+
+  url_formatter::FormatUrlTypes format_types = url_formatter::kFormatUrlOmitAll;
+  if (state_.offline_page)
+    format_types |= url_formatter::kFormatUrlExperimentalOmitHTTPS;
+
   const base::string16 text = url_formatter::FormatUrl(
-      state_.gurl, url_formatter::kFormatUrlOmitAll, net::UnescapeRule::NORMAL,
-      &parsed, nullptr, nullptr);
+      state_.gurl, format_types, net::UnescapeRule::NORMAL, &parsed, nullptr,
+      nullptr);
 
   int pixel_font_height = texture_size.height() * kFontHeight / kHeight;
 
   gfx::FontList font_list;
   if (!GetFontList(pixel_font_height, text, &font_list))
     failure_callback_.Run(UiUnsupportedMode::kUnhandledCodePoint);
 
   std::unique_ptr<gfx::RenderText> render_text(
       gfx::RenderText::CreateInstance());
   render_text->SetFontList(font_list);
@@ skipping 95 matching lines @@
 
 gfx::Size UrlBarTexture::GetPreferredTextureSize(int maximum_width) const {
   return gfx::Size(maximum_width, maximum_width * kHeight / kWidth);
 }
 
 gfx::SizeF UrlBarTexture::GetDrawnSize() const {
   return size_;
 }
 
 }  // namespace vr_shell