[Athena] Simple pull to refresh implementation

athena/content/web_activity.cc

 // Copyright 2014 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 "athena/content/web_activity.h"
 
 #include "athena/activity/public/activity_factory.h"
 #include "athena/activity/public/activity_manager.h"
 #include "athena/content/public/dialogs.h"
 #include "athena/input/public/accelerator_manager.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/public/browser/native_web_keyboard_event.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/common/content_switches.h"
 #include "ui/aura/window.h"
 #include "ui/compositor/closure_animation_observer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
+#include "ui/views/background.h"
+#include "ui/views/controls/label.h"
 #include "ui/views/controls/webview/unhandled_keyboard_event_handler.h"
 #include "ui/views/controls/webview/webview.h"
 #include "ui/views/focus/focus_manager.h"
 #include "ui/views/widget/widget.h"
 
 namespace athena {
 namespace {
 
 class WebActivityController : public AcceleratorHandler {
  public:
@@ skipping 107 matching lines @@
   views::WebView* web_view_;
   bool reserved_accelerator_enabled_;
   scoped_ptr<AcceleratorManager> accelerator_manager_;
   views::UnhandledKeyboardEventHandler unhandled_keyboard_event_handler_;
 
   DISALLOW_COPY_AND_ASSIGN(WebActivityController);
 };
 
 const SkColor kDefaultTitleColor = SkColorSetRGB(0xf2, 0xf2, 0xf2);
 const SkColor kDefaultUnavailableColor = SkColorSetRGB(0xbb, 0x77, 0x77);
+const int kDistanceShowReloadMessage = 30;
+const int kDistanceReload = 70;
 
 }  // namespace
 
 // A web view for athena's web activity. Note that AthenaWebView will create its
 // own content so that it can eject and reload it.
 class AthenaWebView : public views::WebView {
  public:
   AthenaWebView(content::BrowserContext* context)
       : views::WebView(context), controller_(new WebActivityController(this)),
-        fullscreen_(false) {
+        fullscreen_(false),
+        overscroll_y_(0) {
     SetEmbedFullscreenWidgetMode(true);
     // TODO(skuhne): Add content observer to detect renderer crash and set
     // content status to unloaded if that happens.
   }
 
   AthenaWebView(content::WebContents* web_contents)
       : views::WebView(web_contents->GetBrowserContext()),
         controller_(new WebActivityController(this)) {
     scoped_ptr<content::WebContents> old_contents(
         SwapWebContents(scoped_ptr<content::WebContents>(web_contents)));
@@ skipping 64 matching lines @@
     // NULL is returned if the URL wasn't opened immediately.
     return NULL;
   }
 
   virtual bool CanOverscrollContent() const OVERRIDE {
     const std::string value = CommandLine::ForCurrentProcess()->
         GetSwitchValueASCII(switches::kOverscrollHistoryNavigation);
     return value != "0";
   }
 
+  virtual void OverscrollUpdate(int delta_y) OVERRIDE {
+    overscroll_y_ = delta_y;
+    if (overscroll_y_ > kDistanceShowReloadMessage) {
+      if (!reload_message_)
+        CreateReloadMessage();
+      reload_message_->Show();
+      float opacity = (overscroll_y_ - kDistanceReload) /
+          static_cast<float>(kDistanceReload - kDistanceShowReloadMessage);
+      reload_message_->GetLayer()->SetOpacity(std::min(1.0f, opacity));

[sadrul, 2014/09/11 04:33:14]

opacity will be negative when overscroll_y_ < kDistanceReload.

Try using gfx::Tween::FloatValueBetween() instead.

[pkotwicz, 2014/09/11 22:51:40]

Thanks for catching this.

I cannot use gfx::Tween::FloatValueBetween().
- gfx::Tween::FloatValueBetween() does not guarantee the value's range.
- gfx::Tween::FloatValueBetween() is used to convert a value in the range [0,1]
to a value in a range [start, end] (unfortunately not the other way around)

+    } else if (reload_message_) {
+      reload_message_->Hide();
+    }
+  }
+
+  virtual void OverscrollComplete() OVERRIDE {
+    if (overscroll_y_ >= kDistanceReload) {
+      reload_message_->Hide();
+      overscroll_y_ = 0;
+
+      GetWebContents()->GetController().Reload(false);
+    }
+  }
+
   virtual void AddNewContents(content::WebContents* source,
                               content::WebContents* new_contents,
                               WindowOpenDisposition disposition,
                               const gfx::Rect& initial_pos,
                               bool user_gesture,
                               bool* was_blocked) OVERRIDE {
     ActivityManager::Get()->AddActivity(
         new WebActivity(new AthenaWebView(new_contents)));
   }
 
@@ skipping 64 matching lines @@
     return athena::OpenFileChooser(web_contents, params);
   }
 
  private:
   void CreateProgressBar() {
     CHECK(!progress_bar_);
     progress_bar_.reset(new ui::Layer(ui::LAYER_SOLID_COLOR));
     progress_bar_->SetColor(SkColorSetRGB(0x17, 0x59, 0xcd));
   }
 
+  void CreateReloadMessage() {
+    CHECK(!reload_message_);
+    reload_message_.reset(new views::Widget);
+    views::Widget::InitParams params(views::Widget::InitParams::TYPE_CONTROL);
+    params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
+    params.parent = GetWidget()->GetNativeView();
+    reload_message_->Init(params);
+
+    views::Label* label = new views::Label(base::UTF8ToUTF16("Reload"));
+    label->SetBackgroundColor(SK_ColorGRAY);
+    label->set_background(
+        views::Background::CreateSolidBackground(SK_ColorGRAY));
+
+    reload_message_->SetContentsView(label);
+    reload_message_->SetBounds(ConvertRectToWidget(
+        gfx::Rect(0, 0, width(), label->GetPreferredSize().height())));
+  }
+
   scoped_ptr<WebActivityController> controller_;
 
   // If the activity got evicted, this is the web content which holds the known
   // state of the content before eviction.
   scoped_ptr<content::WebContents> evicted_web_contents_;
 
   scoped_ptr<ui::Layer> progress_bar_;
 
+  scoped_ptr<views::Widget> reload_message_;
+
   // TODO(oshima): Find out if we should support window fullscreen.
   // It may still useful when a user is in split mode.
   bool fullscreen_;
 
+  // The distance that the user has overscrolled vertically.
+  int overscroll_y_;
+
   DISALLOW_COPY_AND_ASSIGN(AthenaWebView);
 };
 
 WebActivity::WebActivity(content::BrowserContext* browser_context,
                          const base::string16& title,
                          const GURL& url)
     : browser_context_(browser_context),
       title_(title),
       url_(url),
       web_view_(NULL),
@@ skipping 192 matching lines @@
 
 void WebActivity::ReloadAndObserve() {
   if (web_view_->IsContentEvicted()) {
     DCHECK_EQ(ACTIVITY_UNLOADED, current_state_);
     web_view_->ReloadContent();
   }
   Observe(web_view_->GetWebContents());
 }
 
 }  // namespace athena