Fix window.close() in Athena

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/content_proxy.h"
 #include "athena/content/media_utils.h"
@@ skipping 29 matching lines @@
  public:
   enum Command {
     CMD_BACK,
     CMD_FORWARD,
     CMD_RELOAD,
     CMD_RELOAD_IGNORE_CACHE,
     CMD_CLOSE,
     CMD_STOP,
   };
 
-  explicit WebActivityController(views::WebView* web_view)
-      : web_view_(web_view), reserved_accelerator_enabled_(true) {}
+  explicit WebActivityController(WebActivity* owner_activity,
+                                 views::WebView* web_view)
+      : owner_activity_(owner_activity),
+        web_view_(web_view),
+        reserved_accelerator_enabled_(true) {}
   virtual ~WebActivityController() {}
 
   // Installs accelerators for web activity.
   void InstallAccelerators() {
     accelerator_manager_ = AcceleratorManager::CreateForFocusManager(
                                web_view_->GetFocusManager()).Pass();
     const AcceleratorData accelerator_data[] = {
         {TRIGGER_ON_PRESS, ui::VKEY_R, ui::EF_CONTROL_DOWN, CMD_RELOAD,
          AF_NONE},
         {TRIGGER_ON_PRESS, ui::VKEY_BROWSER_REFRESH, ui::EF_NONE, CMD_RELOAD,
@@ skipping 67 matching lines @@
       case CMD_RELOAD_IGNORE_CACHE:
         web_view_->GetWebContents()->GetController().ReloadIgnoringCache(false);
         return true;
       case CMD_BACK:
         web_view_->GetWebContents()->GetController().GoBack();
         return true;
       case CMD_FORWARD:
         web_view_->GetWebContents()->GetController().GoForward();
         return true;
       case CMD_CLOSE:
-        web_view_->GetWidget()->Close();
+        Activity::Delete(owner_activity_);
         return true;
       case CMD_STOP:
         web_view_->GetWebContents()->Stop();
         return true;
     }
     return false;
   }
 
+  Activity* const owner_activity_;
   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 int kIconSize = 32;
 const float kDistanceShowReloadMessage = 100;
 const float kDistanceReload = 150;
 
 }  // 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:
-  explicit AthenaWebView(content::BrowserContext* context)
+  explicit AthenaWebView(content::BrowserContext* context,
+                         WebActivity* owner_activity)
       : views::WebView(context),
-        controller_(new WebActivityController(this)),
+        controller_(new WebActivityController(owner_activity, this)),
+        owner_activity_(owner_activity),
         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)
+  AthenaWebView(content::WebContents* web_contents,
+                WebActivity* owner_activity)
       : views::WebView(web_contents->GetBrowserContext()),
-        controller_(new WebActivityController(this)) {
+        controller_(new WebActivityController(owner_activity, this)),
+        owner_activity_(owner_activity) {
     scoped_ptr<content::WebContents> old_contents(
         SwapWebContents(scoped_ptr<content::WebContents>(web_contents)));
   }
 
   virtual ~AthenaWebView() {}
 
   void InstallAccelerators() { controller_->InstallAccelerators(); }
 
   void EvictContent() {
     scoped_ptr<content::WebContents> old_contents(SwapWebContents(
@@ skipping 173 matching lines @@
     return athena::OpenColorChooser(web_contents, color, suggestions);
   }
 
   // Called when a file selection is to be done.
   virtual void RunFileChooser(
       content::WebContents* web_contents,
       const content::FileChooserParams& params) override {
     return athena::OpenFileChooser(web_contents, params);
   }
 
+  virtual void CloseContents(content::WebContents* contents) override {
+    Activity::Delete(owner_activity_);
+  }
+
  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(
         l10n_util::GetStringUTF16(IDS_ATHENA_PULL_TO_RELOAD_MESSAGE));
     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_;
 
+  Activity* const owner_activity_;
+
   // 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.
   float overscroll_y_;
 
   DISALLOW_COPY_AND_ASSIGN(AthenaWebView);
 };
 
 WebActivity::WebActivity(content::BrowserContext* browser_context,
                          const base::string16& title,
                          const GURL& url)
     : browser_context_(browser_context),
-      web_view_(new AthenaWebView(browser_context)),
+      web_view_(new AthenaWebView(browser_context, this)),
       title_(title),
       title_color_(kDefaultTitleColor),
       current_state_(ACTIVITY_UNLOADED),
       weak_ptr_factory_(this) {
   // Order is important. The web activity helpers must be attached prior to the
   // RenderView being created.
   SetCurrentState(ACTIVITY_INVISIBLE);
   web_view_->LoadInitialURL(url);
 }
 
 WebActivity::WebActivity(content::WebContents* contents)
     : browser_context_(contents->GetBrowserContext()),
-      web_view_(new AthenaWebView(contents)),
+      web_view_(new AthenaWebView(contents, this)),
       title_color_(kDefaultTitleColor),
       current_state_(ACTIVITY_UNLOADED),
       weak_ptr_factory_(this) {
   // If the activity was created as a result of
   // WebContentsDelegate::AddNewContents(), web activity helpers may not be
   // created prior to the RenderView being created. Desktop Chrome has a
   // similar problem.
   SetCurrentState(ACTIVITY_INVISIBLE);
 }
 
@@ skipping 180 matching lines @@
   if (content_proxy_.get())
     content_proxy_.reset(NULL);
 }
 
 void WebActivity::ShowContentProxy() {
   if (!content_proxy_.get())
     content_proxy_.reset(new ContentProxy(web_view_));
 }
 
 }  // namespace athena