Implement the 2016Q2 Translate UI designe spec out in

chrome/browser/ui/views/translate/translate_bubble_view_unittest.cc

 // Copyright 2013 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/ui/views/translate/translate_bubble_view.h"
 
 #include <memory>
 #include <utility>
 
+#include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/ui/translate/translate_bubble_model.h"
 #include "chrome/browser/ui/translate/translate_bubble_view_state_transition.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "ui/events/event_constants.h"
+#include "ui/events/event_utils.h"
+#include "ui/gfx/range/range.h"
+#include "ui/views/bubble/bubble_frame_view.h"
 #include "ui/views/controls/button/checkbox.h"
 #include "ui/views/controls/combobox/combobox.h"
+#include "ui/views/controls/styled_label.h"
 #include "ui/views/test/combobox_test_api.h"
 #include "ui/views/test/views_test_base.h"
 #include "ui/views/widget/widget.h"
 
 namespace {
 
 class MockTranslateBubbleModel : public TranslateBubbleModel {
  public:
   explicit MockTranslateBubbleModel(TranslateBubbleModel::ViewState view_state)
       : view_state_transition_(view_state),
         error_type_(translate::TranslateErrors::NONE),
         original_language_index_(0),
         target_language_index_(1),
         never_translate_language_(false),
         never_translate_site_(false),
         should_always_translate_(false),
+        always_translate_checked_(false),
         set_always_translate_called_count_(0),
         translate_called_(false),
         revert_translation_called_(false),
         translation_declined_(false),
         original_language_index_on_translation_(-1),
         target_language_index_on_translation_(-1) {}
 
   TranslateBubbleModel::ViewState GetViewState() const override {
     return view_state_transition_.view_state();
   }
 
   void SetViewState(TranslateBubbleModel::ViewState view_state) override {
     view_state_transition_.SetViewState(view_state);
   }
 
   void ShowError(translate::TranslateErrors::Type error_type) override {
     error_type_ = error_type;
   }
 
   void GoBackFromAdvanced() override {
     view_state_transition_.GoBackFromAdvanced();
   }
 
   int GetNumberOfLanguages() const override { return 1000; }
 
   base::string16 GetLanguageNameAt(int index) const override {
-    return base::string16();
+    return base::ASCIIToUTF16("English");
   }
 
   int GetOriginalLanguageIndex() const override {
     return original_language_index_;
   }
 
   void UpdateOriginalLanguageIndex(int index) override {
     original_language_index_ = index;
   }
 
   int GetTargetLanguageIndex() const override { return target_language_index_; }
 
   void UpdateTargetLanguageIndex(int index) override {
     target_language_index_ = index;
   }
 
   void DeclineTranslation() override { translation_declined_ = true; }
 
   void SetNeverTranslateLanguage(bool value) override {
     never_translate_language_ = value;
   }
 
   void SetNeverTranslateSite(bool value) override {
     never_translate_site_ = value;
   }
 
+  bool GetAlwaysTranslateChecked() const override {
+    return always_translate_checked_;
+  }
   bool ShouldAlwaysTranslate() const override {

[msw, 2016/04/29 20:00:02]

nit: blank line above

[ftang, 2016/04/29 22:37:02]

Done.

     return should_always_translate_;
   }
 
   void SetAlwaysTranslate(bool value) override {
     should_always_translate_ = value;
     set_always_translate_called_count_++;
   }
 
   void Translate() override {
     translate_called_ = true;
@@ skipping 11 matching lines @@
         target_language_index_on_translation_ == target_language_index_;
   }
 
   TranslateBubbleViewStateTransition view_state_transition_;
   translate::TranslateErrors::Type error_type_;
   int original_language_index_;
   int target_language_index_;
   bool never_translate_language_;
   bool never_translate_site_;
   bool should_always_translate_;
+  bool always_translate_checked_;
   int set_always_translate_called_count_;
   bool translate_called_;
   bool revert_translation_called_;
   bool translation_declined_;
   int original_language_index_on_translation_;
   int target_language_index_on_translation_;
 };
 
 }  // namespace
 
@@ skipping 10 matching lines @@
     views::Widget::InitParams params =
         CreateParams(views::Widget::InitParams::TYPE_WINDOW);
     params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
 
     anchor_widget_.reset(new views::Widget());
     anchor_widget_->Init(params);
     anchor_widget_->Show();
 
     mock_model_ = new MockTranslateBubbleModel(
         TranslateBubbleModel::VIEW_STATE_BEFORE_TRANSLATE);
+
+    base::FeatureList::ClearInstanceForTesting();
+    base::FeatureList::SetInstance(base::WrapUnique(new base::FeatureList));
+  }
+
+  void TurnOnTranslate2016Q2UIFlag() {
+    base::FeatureList::ClearInstanceForTesting();
+    std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList);
+    feature_list->InitializeFromCommandLine(
+        translate::kTranslateUI2016Q2.name, "");

[msw, 2016/04/29 20:00:02]

nit: s/""/std::string()/

[ftang, 2016/04/29 22:37:02]

Done.

+    base::FeatureList::SetInstance(std::move(feature_list));
+  }
+
+  void CreateAndShowBubble() {
     std::unique_ptr<TranslateBubbleModel> model(mock_model_);
     bubble_ = new TranslateBubbleView(anchor_widget_->GetContentsView(),
                                       std::move(model),
                                       translate::TranslateErrors::NONE, NULL);
     views::BubbleDialogDelegateView::CreateBubble(bubble_)->Show();
   }
 
   void TearDown() override {
     bubble_->GetWidget()->CloseNow();
     anchor_widget_.reset();
 
     views::ViewsTestBase::TearDown();
   }
 
   views::Combobox* denial_combobox() { return bubble_->denial_combobox_; }
   bool denial_button_clicked() { return mock_model_->translation_declined_; }
 
   std::unique_ptr<views::Widget> anchor_widget_;
   MockTranslateBubbleModel* mock_model_;
   TranslateBubbleView* bubble_;
 };
 
 TEST_F(TranslateBubbleViewTest, TranslateButton) {
+  CreateAndShowBubble();
   EXPECT_FALSE(mock_model_->translate_called_);
 
   // Press the "Translate" button.
+  bubble_->HandleButtonPressed(TranslateBubbleView::BUTTON_ID_TRANSLATE);
+  EXPECT_TRUE(mock_model_->translate_called_);
+}
+
+TEST_F(TranslateBubbleViewTest, TranslateButtonIn2016Q2UI) {
+  TurnOnTranslate2016Q2UIFlag();
+  CreateAndShowBubble();
+  EXPECT_FALSE(mock_model_->translate_called_);
+
+  // Press the "Translate" button.
   bubble_->HandleButtonPressed(TranslateBubbleView::BUTTON_ID_TRANSLATE);
   EXPECT_TRUE(mock_model_->translate_called_);
 }
 
+TEST_F(TranslateBubbleViewTest, CloseButtonIn2016Q2UI) {
+  TurnOnTranslate2016Q2UIFlag();
+  CreateAndShowBubble();
+  EXPECT_FALSE(mock_model_->translate_called_);
+  EXPECT_FALSE(mock_model_->translation_declined_);
+  EXPECT_FALSE(bubble_->GetWidget()->IsClosed());
+
+  // Press the "Close" button.
+  bubble_->GetBubbleFrameView()->ButtonPressed(

[msw, 2016/04/29 20:00:02]

nit: maybe use EventGenerator.

[ftang, 2016/04/29 22:37:02]

Acknowledged.

+      bubble_->GetBubbleFrameView()->close_,
+      ui::MouseEvent(ui::ET_MOUSE_PRESSED, gfx::Point(), gfx::Point(),
+                     ui::EventTimeForNow(), ui::EF_NONE, ui::EF_NONE));
+
+  EXPECT_FALSE(mock_model_->translate_called_);
+  EXPECT_TRUE(mock_model_->translation_declined_);
+}
+
 TEST_F(TranslateBubbleViewTest, ComboboxNope) {
+  CreateAndShowBubble();
   views::test::ComboboxTestApi test_api(denial_combobox());
   EXPECT_FALSE(denial_button_clicked());
   EXPECT_FALSE(bubble_->GetWidget()->IsClosed());
 
   test_api.PerformActionAt(static_cast<int>(
       TranslateBubbleView::DenialComboboxIndex::DONT_TRANSLATE));
   EXPECT_TRUE(denial_button_clicked());
   EXPECT_TRUE(bubble_->GetWidget()->IsClosed());
 }
 
+TEST_F(TranslateBubbleViewTest, ComboboxNopeIn2016Q2UI) {
+  TurnOnTranslate2016Q2UIFlag();
+  CreateAndShowBubble();
+  views::test::ComboboxTestApi test_api(denial_combobox());
+  EXPECT_FALSE(denial_button_clicked());
+  EXPECT_FALSE(bubble_->GetWidget()->IsClosed());
+
+  test_api.PerformActionAt(static_cast<int>(
+      TranslateBubbleView::DenialComboboxIndex::DONT_TRANSLATE));
+
+  // In the 2016Q2 UI, we should not close nor take action.

[msw, 2016/04/29 20:00:02]

Isn't the 'nope' button simply not available in the new UI? I'm not sure it
makes sense to test your workaround to no-op when the non-existent button is
pressed...

[ftang, 2016/04/29 22:37:02]

no, that is not true. the menu item will be there but the clicking should have
no effect. User will still see it.

[msw, 2016/04/29 23:43:39]

Sorry, in the mocks it doesn't show a 'Nope' button. It shows [Translate],
[Never (site)], [Never (lang)] under the [Options] button, a close (x), and an
[Always] checkbox; where is the [Nope] button? Can you post a screenshot with
this button?
https://docs.google.com/presentation/d/1QECg9ZPANcOISaiS3tEDgOj4yJNSFnPhq2VWE...

It sounds like you saying that there is a [Nope] button that won't even close
the bubble, so users can repeatedly click [Nope] and the bubble will do
*nothing*, even though users (myself included) would expect it to close the
bubble. I hope I'm just misunderstanding your meaning... can you clarify?

+  EXPECT_FALSE(denial_button_clicked());
+  EXPECT_FALSE(bubble_->GetWidget()->IsClosed());
+}
+
 TEST_F(TranslateBubbleViewTest, ComboboxNeverTranslateLanguage) {
+  CreateAndShowBubble();
   views::test::ComboboxTestApi test_api(denial_combobox());
   EXPECT_FALSE(bubble_->GetWidget()->IsClosed());
   EXPECT_FALSE(mock_model_->never_translate_language_);
+  EXPECT_FALSE(denial_button_clicked());
+
+  test_api.PerformActionAt(static_cast<int>(
+      TranslateBubbleView::DenialComboboxIndex::NEVER_TRANSLATE_LANGUAGE));
+  EXPECT_TRUE(denial_button_clicked());
+  EXPECT_TRUE(mock_model_->never_translate_language_);
+  EXPECT_TRUE(bubble_->GetWidget()->IsClosed());
+}
+
+TEST_F(TranslateBubbleViewTest, ComboboxNeverTranslateLanguageIn2016Q2UI) {
+  TurnOnTranslate2016Q2UIFlag();
+  CreateAndShowBubble();
+  views::test::ComboboxTestApi test_api(denial_combobox());
+  EXPECT_FALSE(bubble_->GetWidget()->IsClosed());
+  EXPECT_FALSE(mock_model_->never_translate_language_);
   EXPECT_FALSE(denial_button_clicked());
 
   test_api.PerformActionAt(static_cast<int>(
       TranslateBubbleView::DenialComboboxIndex::NEVER_TRANSLATE_LANGUAGE));
   EXPECT_TRUE(denial_button_clicked());
   EXPECT_TRUE(mock_model_->never_translate_language_);
   EXPECT_TRUE(bubble_->GetWidget()->IsClosed());
 }
 
 TEST_F(TranslateBubbleViewTest, ComboboxNeverTranslateSite) {
+  CreateAndShowBubble();
   views::test::ComboboxTestApi test_api(denial_combobox());
   EXPECT_FALSE(mock_model_->never_translate_site_);
   EXPECT_FALSE(denial_button_clicked());
+  EXPECT_FALSE(bubble_->GetWidget()->IsClosed());
+
+  test_api.PerformActionAt(static_cast<int>(
+      TranslateBubbleView::DenialComboboxIndex::NEVER_TRANSLATE_SITE));
+  EXPECT_TRUE(denial_button_clicked());
+  EXPECT_TRUE(mock_model_->never_translate_site_);
+  EXPECT_TRUE(bubble_->GetWidget()->IsClosed());
+}
+
+TEST_F(TranslateBubbleViewTest, ComboboxNeverTranslateSiteIn2016Q2UI) {
+  TurnOnTranslate2016Q2UIFlag();
+  CreateAndShowBubble();
+  views::test::ComboboxTestApi test_api(denial_combobox());
+  EXPECT_FALSE(mock_model_->never_translate_site_);
+  EXPECT_FALSE(denial_button_clicked());
   EXPECT_FALSE(bubble_->GetWidget()->IsClosed());
 
   test_api.PerformActionAt(static_cast<int>(
       TranslateBubbleView::DenialComboboxIndex::NEVER_TRANSLATE_SITE));
   EXPECT_TRUE(denial_button_clicked());
   EXPECT_TRUE(mock_model_->never_translate_site_);
   EXPECT_TRUE(bubble_->GetWidget()->IsClosed());
 }
 
 TEST_F(TranslateBubbleViewTest, AdvancedLink) {
+  CreateAndShowBubble();
   EXPECT_EQ(TranslateBubbleModel::VIEW_STATE_BEFORE_TRANSLATE,
             bubble_->GetViewState());
 
   // Click the "Advanced" link.
   bubble_->HandleLinkClicked(TranslateBubbleView::LINK_ID_ADVANCED);
   EXPECT_EQ(TranslateBubbleModel::VIEW_STATE_ADVANCED, bubble_->GetViewState());
 }
 
+TEST_F(TranslateBubbleViewTest, AdvancedLinkIn2016Q2UI) {
+  TurnOnTranslate2016Q2UIFlag();
+  CreateAndShowBubble();
+  EXPECT_EQ(TranslateBubbleModel::VIEW_STATE_BEFORE_TRANSLATE,
+            bubble_->GetViewState());
+
+  // call the StyledLabelLinkClicked();

[msw, 2016/04/29 20:00:02]

nit: "Click the styled label link."

[ftang, 2016/04/29 22:37:02]

Done.

+  views::StyledLabel styled_label(base::ASCIIToUTF16("test"), nullptr);

[msw, 2016/04/29 20:00:02]

You don't need to supply a valid styled label here; pass nullptr instead.

[ftang, 2016/04/29 22:37:02]

no, I tried it. It won't work and will give me error.

+  bubble_->StyledLabelLinkClicked(&styled_label, gfx::Range(), ui::EF_NONE);
+  EXPECT_EQ(TranslateBubbleModel::VIEW_STATE_ADVANCED, bubble_->GetViewState());
+}
+
 TEST_F(TranslateBubbleViewTest, ShowOriginalButton) {
+  CreateAndShowBubble();
   bubble_->SwitchView(TranslateBubbleModel::VIEW_STATE_AFTER_TRANSLATE);
 
   // Click the "Show original" button to revert translation.
   EXPECT_FALSE(mock_model_->revert_translation_called_);
   bubble_->HandleButtonPressed(TranslateBubbleView::BUTTON_ID_SHOW_ORIGINAL);
   EXPECT_TRUE(mock_model_->revert_translation_called_);
 }
 
 TEST_F(TranslateBubbleViewTest, TryAgainButton) {
+  CreateAndShowBubble();
   bubble_->SwitchToErrorView(translate::TranslateErrors::NETWORK);
 
   EXPECT_EQ(translate::TranslateErrors::NETWORK, mock_model_->error_type_);
 
   // Click the "Try again" button to translate.
   EXPECT_FALSE(mock_model_->translate_called_);
   bubble_->HandleButtonPressed(TranslateBubbleView::BUTTON_ID_TRY_AGAIN);
   EXPECT_TRUE(mock_model_->translate_called_);
 }
 
 TEST_F(TranslateBubbleViewTest, AlwaysTranslateCheckboxAndCancelButton) {
+  CreateAndShowBubble();
   bubble_->SwitchView(TranslateBubbleModel::VIEW_STATE_ADVANCED);
 
   // Click the "Always Translate" checkbox. Changing the state of this checkbox
   // should NOT affect the model after pressing the cancel button.
 
   // Check the initial state.
   EXPECT_FALSE(mock_model_->should_always_translate_);
   EXPECT_EQ(0, mock_model_->set_always_translate_called_count_);
   EXPECT_FALSE(bubble_->always_translate_checkbox_->checked());
 
   // Click the checkbox. The state is not saved yet.
   bubble_->always_translate_checkbox_->SetChecked(true);
   bubble_->HandleButtonPressed(TranslateBubbleView::BUTTON_ID_ALWAYS_TRANSLATE);
   EXPECT_FALSE(mock_model_->should_always_translate_);
   EXPECT_EQ(0, mock_model_->set_always_translate_called_count_);
 
   // Click the cancel button. The state is not saved.
   bubble_->HandleButtonPressed(TranslateBubbleView::BUTTON_ID_CANCEL);
   EXPECT_FALSE(mock_model_->should_always_translate_);
   EXPECT_EQ(0, mock_model_->set_always_translate_called_count_);
 }
 
 TEST_F(TranslateBubbleViewTest, AlwaysTranslateCheckboxAndDoneButton) {
+  CreateAndShowBubble();
   bubble_->SwitchView(TranslateBubbleModel::VIEW_STATE_ADVANCED);
 
   // Click the "Always Translate" checkbox. Changing the state of this checkbox
   // should affect the model after pressing the done button.
 
   // Check the initial state.
   EXPECT_FALSE(mock_model_->should_always_translate_);
   EXPECT_EQ(0, mock_model_->set_always_translate_called_count_);
   EXPECT_FALSE(bubble_->always_translate_checkbox_->checked());
 
   // Click the checkbox. The state is not saved yet.
   bubble_->always_translate_checkbox_->SetChecked(true);
   bubble_->HandleButtonPressed(TranslateBubbleView::BUTTON_ID_ALWAYS_TRANSLATE);
   EXPECT_FALSE(mock_model_->should_always_translate_);
   EXPECT_EQ(0, mock_model_->set_always_translate_called_count_);
 
   // Click the done button. The state is saved.
   bubble_->HandleButtonPressed(TranslateBubbleView::BUTTON_ID_DONE);
   EXPECT_TRUE(mock_model_->should_always_translate_);
   EXPECT_EQ(1, mock_model_->set_always_translate_called_count_);
 }
 
 TEST_F(TranslateBubbleViewTest, DoneButton) {
+  CreateAndShowBubble();
   bubble_->SwitchView(TranslateBubbleModel::VIEW_STATE_ADVANCED);
 
   // Click the "Done" button to translate. The selected languages by the user
   // are applied.
   EXPECT_FALSE(mock_model_->translate_called_);
   bubble_->source_language_combobox_->SetSelectedIndex(10);
   bubble_->HandleComboboxPerformAction(
       TranslateBubbleView::COMBOBOX_ID_SOURCE_LANGUAGE);
   bubble_->target_language_combobox_->SetSelectedIndex(20);
   bubble_->HandleComboboxPerformAction(
       TranslateBubbleView::COMBOBOX_ID_TARGET_LANGUAGE);
   bubble_->HandleButtonPressed(TranslateBubbleView::BUTTON_ID_DONE);
   EXPECT_TRUE(mock_model_->translate_called_);
   EXPECT_EQ(10, mock_model_->original_language_index_);
   EXPECT_EQ(20, mock_model_->target_language_index_);
 }
 
 TEST_F(TranslateBubbleViewTest, DoneButtonWithoutTranslating) {
+  CreateAndShowBubble();
   EXPECT_EQ(TranslateBubbleModel::VIEW_STATE_BEFORE_TRANSLATE,
             bubble_->GetViewState());
 
   // Translate the page once.
   mock_model_->Translate();
   EXPECT_TRUE(mock_model_->translate_called_);
 
   // Go back to the initial view.
   EXPECT_EQ(TranslateBubbleModel::VIEW_STATE_BEFORE_TRANSLATE,
             bubble_->GetViewState());
   mock_model_->translate_called_ = false;
 
   EXPECT_EQ(TranslateBubbleModel::VIEW_STATE_BEFORE_TRANSLATE,
             bubble_->GetViewState());
   bubble_->SwitchView(TranslateBubbleModel::VIEW_STATE_ADVANCED);
 
   // Click the "Done" button with the current language pair. This time,
   // translation is not performed and the view state will be back to the
   // previous view.
   bubble_->HandleButtonPressed(TranslateBubbleView::BUTTON_ID_DONE);
   EXPECT_FALSE(mock_model_->translate_called_);
 
   EXPECT_EQ(TranslateBubbleModel::VIEW_STATE_BEFORE_TRANSLATE,
             bubble_->GetViewState());
 }
 
 TEST_F(TranslateBubbleViewTest, CancelButtonReturningBeforeTranslate) {
+  CreateAndShowBubble();
   bubble_->SwitchView(TranslateBubbleModel::VIEW_STATE_BEFORE_TRANSLATE);
   bubble_->SwitchView(TranslateBubbleModel::VIEW_STATE_ADVANCED);
 
   // Click the "Cancel" button to go back.
   EXPECT_EQ(TranslateBubbleModel::VIEW_STATE_ADVANCED, bubble_->GetViewState());
   bubble_->HandleButtonPressed(TranslateBubbleView::BUTTON_ID_CANCEL);
   EXPECT_EQ(TranslateBubbleModel::VIEW_STATE_BEFORE_TRANSLATE,
             bubble_->GetViewState());
 }
 
 TEST_F(TranslateBubbleViewTest, CancelButtonReturningAfterTranslate) {
+  CreateAndShowBubble();
   bubble_->SwitchView(TranslateBubbleModel::VIEW_STATE_AFTER_TRANSLATE);
   bubble_->SwitchView(TranslateBubbleModel::VIEW_STATE_ADVANCED);
 
   // Click the "Cancel" button to go back.
   EXPECT_EQ(TranslateBubbleModel::VIEW_STATE_ADVANCED, bubble_->GetViewState());
   bubble_->HandleButtonPressed(TranslateBubbleView::BUTTON_ID_CANCEL);
   EXPECT_EQ(TranslateBubbleModel::VIEW_STATE_AFTER_TRANSLATE,
             bubble_->GetViewState());
 }
 
 TEST_F(TranslateBubbleViewTest, CancelButtonReturningError) {
+  CreateAndShowBubble();
   bubble_->SwitchView(TranslateBubbleModel::VIEW_STATE_ERROR);
   bubble_->SwitchView(TranslateBubbleModel::VIEW_STATE_ADVANCED);
 
   // Click the "Cancel" button to go back.
   EXPECT_EQ(TranslateBubbleModel::VIEW_STATE_ADVANCED, bubble_->GetViewState());
   bubble_->HandleButtonPressed(TranslateBubbleView::BUTTON_ID_CANCEL);
   EXPECT_EQ(TranslateBubbleModel::VIEW_STATE_ERROR, bubble_->GetViewState());
 }