Add browser tests for enabling Google Drive offline mode on first run.

chrome/browser/chromeos/first_run/drive_first_run_controller.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/chromeos/first_run/drive_first_run_controller.h"
 
 #include "ash/shell.h"
 #include "ash/system/tray/system_tray_notifier.h"
 #include "base/callback.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/background/background_contents_service.h"
 #include "chrome/browser/background/background_contents_service_factory.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
+#include "chrome/browser/extensions/extension_web_contents_observer.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/tab_contents/background_contents.h"
 #include "chrome/common/extensions/extension.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "url/gurl.h"
 
 namespace chromeos {
 
 namespace {
 
 // The initial time to wait in seconds before starting the opt-in.
-const int kInitialDelaySeconds = 180;
+int kInitialDelaySeconds = 180;
 
 // Time to wait for Drive app background page to come up before giving up.
-const int kWebContentsTimeoutSeconds = 15;
+int kWebContentsTimeoutSeconds = 15;
 
 // Google Drive offline opt-in endpoint.
 const char kDriveOfflineEndpointUrl[] = "https://drive.google.com/#offline";
 
 // Google Drive app id.
 const char kDriveHostedAppId[] = "apdfllckaahabafndbhieahigkjlhalf";
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // DriveWebContentsManager
 
 // Manages web contents that does Google Drive offline opt-in. We create
 // a background WebContents that loads a Drive endpoint to initialize offline
 // mode. If successful, a background page will be opened to sync the user's
 // files for offline use.
 class DriveWebContentsManager : public content::WebContentsObserver,
                                 public content::WebContentsDelegate,
                                 public content::NotificationObserver {
  public:
   typedef base::Callback<void(bool)> CompletionCallback;
 
   DriveWebContentsManager(Profile* profile,
+                          const std::string& app_id,
+                          const std::string& endpoint_url,
                           const CompletionCallback& completion_callback);
   virtual ~DriveWebContentsManager();
 
   // Start loading the WebContents for the endpoint in the context of the Drive
   // hosted app that will initialize offline mode and open a background page.
   void StartLoad();
 
   // Stop loading the endpoint. The |completion_callback| will not be called.
   void StopLoad();
 
@@ skipping 31 matching lines @@
       const GURL& target_url,
       const std::string& partition_id,
       content::SessionStorageNamespace* session_storage_namespace) OVERRIDE;
 
   // content::NotificationObserver overrides:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
   Profile* profile_;
+  const std::string app_id_;
+  const std::string endpoint_url_;
   scoped_ptr<content::WebContents> web_contents_;
   content::NotificationRegistrar registrar_;
   bool started_;
   CompletionCallback completion_callback_;
   base::WeakPtrFactory<DriveWebContentsManager> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DriveWebContentsManager);
 };
 
 DriveWebContentsManager::DriveWebContentsManager(
     Profile* profile,
+    const std::string& app_id,
+    const std::string& endpoint_url,
     const CompletionCallback& completion_callback)
     : profile_(profile),
+      app_id_(app_id),
+      endpoint_url_(endpoint_url),
       started_(false),
       completion_callback_(completion_callback),
       weak_ptr_factory_(this) {
   DCHECK(!completion_callback_.is_null());
   registrar_.Add(this, chrome::NOTIFICATION_BACKGROUND_CONTENTS_OPENED,
                  content::Source<Profile>(profile_));
 }
 
 DriveWebContentsManager::~DriveWebContentsManager() {
 }
 
 void DriveWebContentsManager::StartLoad() {
   started_ = true;
-  const GURL url(kDriveOfflineEndpointUrl);
+  const GURL url(endpoint_url_);
   content::WebContents::CreateParams create_params(
         profile_, content::SiteInstance::CreateForURL(profile_, url));
 
   web_contents_.reset(content::WebContents::Create(create_params));
   web_contents_->SetDelegate(this);
+  extensions::ExtensionWebContentsObserver::CreateForWebContents(
+      web_contents_.get());
 
   content::NavigationController::LoadURLParams load_params(url);
   load_params.transition_type = content::PAGE_TRANSITION_GENERATED;
   web_contents_->GetController().LoadURLWithParams(load_params);
 
   content::WebContentsObserver::Observe(web_contents_.get());
 }
 
 void DriveWebContentsManager::StopLoad() {
   started_ = false;
@@ skipping 17 matching lines @@
 }
 
 void DriveWebContentsManager::DidFailProvisionalLoad(
     int64 frame_id,
     const string16& frame_unique_name,
     bool is_main_frame,
     const GURL& validated_url,
     int error_code,
     const string16& error_description,
     content::RenderViewHost* render_view_host) {
-  OnOfflineInit(false);
+  if (is_main_frame) {
+    LOG(WARNING) << "Failed to load WebContents to enable offline mode.";
+    OnOfflineInit(false);
+  }
 }
 
 void DriveWebContentsManager::DidFailLoad(
     int64 frame_id,
     const GURL& validated_url,
     bool is_main_frame,
     int error_code,
     const string16& error_description,
     content::RenderViewHost* render_view_host) {
-  OnOfflineInit(false);
+  if (is_main_frame) {
+    LOG(WARNING) << "Failed to load WebContents to enable offline mode.";
+    OnOfflineInit(false);
+  }
 }
 
 bool DriveWebContentsManager::ShouldCreateWebContents(
     content::WebContents* web_contents,
     int route_id,
     WindowContainerType window_container_type,
     const string16& frame_name,
     const GURL& target_url,
     const std::string& partition_id,
     content::SessionStorageNamespace* session_storage_namespace) {
 
   if (window_container_type == WINDOW_CONTAINER_TYPE_NORMAL)
     return true;
 
   // Check that the target URL is for the Drive app.
   ExtensionService* service =
       extensions::ExtensionSystem::Get(profile_)->extension_service();
   const extensions::Extension *extension =
       service->GetInstalledApp(target_url);
-  if (!extension || extension->id() != kDriveHostedAppId)
+  if (!extension || extension->id() != app_id_)
     return true;
 
   // The background contents creation is normally done in Browser, but
   // because we're using a detached WebContents, we need to do it ourselves.
   BackgroundContentsService* background_contents_service =
       BackgroundContentsServiceFactory::GetForProfile(profile_);
 
   // Prevent redirection if background contents already exists.
   if (background_contents_service->GetAppBackgroundContents(
-      UTF8ToUTF16(kDriveHostedAppId))) {
+      UTF8ToUTF16(app_id_))) {
     return false;
   }
   BackgroundContents* contents = background_contents_service
       ->CreateBackgroundContents(content::SiteInstance::Create(profile_),
                                  route_id,
                                  profile_,
                                  frame_name,
-                                 ASCIIToUTF16(kDriveHostedAppId),
+                                 ASCIIToUTF16(app_id_),
                                  partition_id,
                                  session_storage_namespace);
 
   contents->web_contents()->GetController().LoadURL(
       target_url,
       content::Referrer(),
       content::PAGE_TRANSITION_LINK,
       std::string());
 
   // Return false as we already created the WebContents here.
   return false;
 }
 
 void DriveWebContentsManager::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   if (type == chrome::NOTIFICATION_BACKGROUND_CONTENTS_OPENED) {
     const std::string app_id = UTF16ToUTF8(
         content::Details<BackgroundContentsOpenedDetails>(details)
             ->application_id);
-    if (app_id == kDriveHostedAppId)
+    if (app_id == app_id_)
       OnOfflineInit(true);
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DriveFirstRunController
 
 DriveFirstRunController::DriveFirstRunController()
     : profile_(ProfileManager::GetDefaultProfile()),
-      started_(false) {
+      started_(false),
+      initial_delay_secs_(kInitialDelaySeconds),
+      web_contents_timeout_secs_(kWebContentsTimeoutSeconds),
+      drive_offline_endpoint_url_(kDriveOfflineEndpointUrl),
+      drive_hosted_app_id_(kDriveHostedAppId) {
 }
 
 DriveFirstRunController::~DriveFirstRunController() {
 }
 
 void DriveFirstRunController::EnableOfflineMode() {
   if (!started_) {
     started_ = true;
     initial_delay_timer_.Start(
       FROM_HERE,
-      base::TimeDelta::FromSeconds(kInitialDelaySeconds),
+      base::TimeDelta::FromSeconds(initial_delay_secs_),
       this,
       &DriveFirstRunController::EnableOfflineMode);
     return;
   }
 
   if (!UserManager::Get()->IsLoggedInAsRegularUser()) {
     LOG(ERROR) << "Attempting to enable offline access "
                   "but not logged in a regular user.";
     OnOfflineInit(false);
     return;
   }
 
   ExtensionService* extension_service =
       extensions::ExtensionSystem::Get(profile_)->extension_service();
-  if (!extension_service->GetExtensionById(kDriveHostedAppId, false)) {
+  if (!extension_service->GetExtensionById(drive_hosted_app_id_, false)) {
     LOG(WARNING) << "Drive app is not installed.";
     OnOfflineInit(false);
     return;
   }
 
   BackgroundContentsService* background_contents_service =
       BackgroundContentsServiceFactory::GetForProfile(profile_);
   if (background_contents_service->GetAppBackgroundContents(
-      UTF8ToUTF16(kDriveHostedAppId))) {
+      UTF8ToUTF16(drive_hosted_app_id_))) {
     LOG(WARNING) << "Background page for Drive app already exists";
     OnOfflineInit(false);
     return;
   }
 
   web_contents_manager_.reset(new DriveWebContentsManager(
       profile_,
+      drive_hosted_app_id_,
+      drive_offline_endpoint_url_,
       base::Bind(&DriveFirstRunController::OnOfflineInit,
                  base::Unretained(this))));
   web_contents_manager_->StartLoad();
   web_contents_timer_.Start(
       FROM_HERE,
-      base::TimeDelta::FromSeconds(kWebContentsTimeoutSeconds),
+      base::TimeDelta::FromSeconds(web_contents_timeout_secs_),
       this,
       &DriveFirstRunController::OnWebContentsTimedOut);
 }
 
+void DriveFirstRunController::AddObserver(Observer* observer) {
+  observer_list_.AddObserver(observer);
+}
+
+void DriveFirstRunController::RemoveObserver(Observer* observer) {
+  observer_list_.RemoveObserver(observer);
+}
+
+void DriveFirstRunController::SetDelaysForTest(int initial_delay_secs,
+                                               int timeout_secs) {
+  DCHECK(!started_);
+  initial_delay_secs_ = initial_delay_secs;
+  web_contents_timeout_secs_ = timeout_secs;
+}
+
+void DriveFirstRunController::SetAppInfoForTest(
+    const std::string& app_id,
+    const std::string& endpoint_url) {
+  DCHECK(!started_);
+  drive_hosted_app_id_ = app_id;
+  drive_offline_endpoint_url_ = endpoint_url;
+}
+
 void DriveFirstRunController::OnWebContentsTimedOut() {
   LOG(WARNING) << "Timed out waiting for web contents to opt-in";
+  FOR_EACH_OBSERVER(Observer, observer_list_, OnTimedOut());
   OnOfflineInit(false);
 }
 
 void DriveFirstRunController::CleanUp() {
   if (web_contents_manager_)
     web_contents_manager_->StopLoad();
   web_contents_timer_.Stop();
   base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 }
 
 void DriveFirstRunController::OnOfflineInit(bool success) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-  ash::Shell::GetInstance()->system_tray_notifier()
-      ->NotifyDriveOfflineEnabled();
+  if (success) {
+    ash::Shell::GetInstance()->system_tray_notifier()
+        ->NotifyDriveOfflineEnabled();
+  }
+  FOR_EACH_OBSERVER(Observer, observer_list_, OnCompletion(success));
   CleanUp();
 }
 
 }  // namespace chromeos