Add FullscreenController::ToggleFullscreenModeWithExtension

chrome/browser/chromeos/media/media_player.cc

 // Copyright (c) 2012 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/media/media_player.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 67 matching lines @@
 }
 
 // static
 MediaPlayer* MediaPlayer::GetInstance() {
   return Singleton<MediaPlayer>::get();
 }
 
 void MediaPlayer::EnqueueMediaFile(Profile* profile,
                                    const FilePath& file_path) {
   GURL url;
-  if (!file_manager_util::ConvertFileToFileSystemUrl(profile, file_path,
-                                                     GetOriginUrl(), &url)) {
-  }
+  file_manager_util::ConvertFileToFileSystemUrl(profile, file_path,
+                                                GetOriginUrl(), &url);
   EnqueueMediaFileUrl(url);
 }
 
 void MediaPlayer::EnqueueMediaFileUrl(const GURL& url) {
   current_playlist_.push_back(MediaUrl(url));
   NotifyPlaylistChanged();
 }
 
 void MediaPlayer::ForcePlayMediaFile(Profile* profile,
                                      const FilePath& file_path) {
   GURL url;
   if (!file_manager_util::ConvertFileToFileSystemUrl(profile, file_path,
-                                                     GetOriginUrl(), &url)) {
+                                                     GetOriginUrl(), &url))
     return;
-  }
   ForcePlayMediaURL(url);
 }
 
 void MediaPlayer::ForcePlayMediaURL(const GURL& url) {
   current_playlist_.clear();
   current_playlist_.push_back(MediaUrl(url));
   current_position_ = current_playlist_.size() - 1;
   pending_playback_request_ = true;
   NotifyPlaylistChanged();
 }
 
 void MediaPlayer::TogglePlaylistWindowVisible() {
-  if (playlist_browser_) {
+  if (playlist_browser_)
     ClosePlaylistWindow();
-  } else {
+  else
     PopupPlaylist(NULL);
-  }
 }
 
 void MediaPlayer::ClosePlaylistWindow() {
-  if (playlist_browser_ != NULL) {
+  if (playlist_browser_ != NULL)
     playlist_browser_->window()->Close();
-  }
 }
 
 void MediaPlayer::SetPlaylistPosition(int position) {
   const int playlist_size = current_playlist_.size();
   if (current_position_ < 0 || current_position_ > playlist_size)
     position = current_playlist_.size();
   if (current_position_ != position) {
     current_position_ = position;
     NotifyPlaylistChanged();
   }
 }
 
 void MediaPlayer::SetPlaybackError(GURL const& url) {
   for (size_t x = 0; x < current_playlist_.size(); x++) {
-    if (current_playlist_[x].url == url) {
+    if (current_playlist_[x].url == url)
       current_playlist_[x].haderror = true;
-    }
   }
   NotifyPlaylistChanged();
 }
 
 void MediaPlayer::Observe(int type,
                           const content::NotificationSource& source,
                           const content::NotificationDetails& details) {
   DCHECK(type == chrome::NOTIFICATION_BROWSER_CLOSED);
-  registrar_.Remove(this,
-                    chrome::NOTIFICATION_BROWSER_CLOSED,
-                    source);
-  if (content::Source<Browser>(source).ptr() == mediaplayer_browser_) {
+  registrar_.Remove(this, chrome::NOTIFICATION_BROWSER_CLOSED, source);
+
+  if (content::Source<Browser>(source).ptr() == mediaplayer_browser_)
     mediaplayer_browser_ = NULL;
-  } else if (content::Source<Browser>(source).ptr() == playlist_browser_) {
+  else if (content::Source<Browser>(source).ptr() == playlist_browser_)
     playlist_browser_ = NULL;
-  }
 }
 
 void MediaPlayer::NotifyPlaylistChanged() {
   ExtensionMediaPlayerEventRouter::GetInstance()->NotifyPlaylistChanged();
 }
 
 bool MediaPlayer::GetPendingPlayRequestAndReset() {
   bool result = pending_playback_request_;
   pending_playback_request_ = false;
   return result;
 }
 
 void MediaPlayer::SetPlaybackRequest() {
   pending_playback_request_ = true;
 }
 
 void MediaPlayer::ToggleFullscreen() {
-  if (mediaplayer_browser_) {
-    mediaplayer_browser_->ToggleFullscreenMode(false);
-  }
+  if (mediaplayer_browser_)
+    mediaplayer_browser_->ToggleFullscreenMode();
 }
 
 void MediaPlayer::PopupPlaylist(Browser* creator) {
   if (playlist_browser_)
     return;  // Already opened.
 
   Profile* profile = BrowserList::GetLastActive()->profile();
   playlist_browser_ = Browser::CreateForApp(Browser::TYPE_PANEL,
                                             kMediaPlayerAppName,
                                             gfx::Rect(),
@@ skipping 62 matching lines @@
 // Document Viewer.
 static const char* const supported_mime_type_list[] = {
   "audio/mpeg",
   "video/mp4",
   "audio/mp3"
 };
 
 net::URLRequestJob* MediaPlayer::MaybeInterceptResponse(
     net::URLRequest* request) {
   // Do not intercept this request if it is a download.
-  if (request->load_flags() & net::LOAD_IS_DOWNLOAD) {
+  if (request->load_flags() & net::LOAD_IS_DOWNLOAD)
     return NULL;
-  }
 
   std::string mime_type;
   request->GetMimeType(&mime_type);
   // If it is in our list of known URLs, enqueue the url then
   // Cancel the request so the mediaplayer can handle it when
   // it hits it in the playlist.
   if (supported_mime_types_.find(mime_type) != supported_mime_types_.end()) {
     if (request->referrer() != chrome::kChromeUIMediaplayerURL &&
         !request->referrer().empty()) {
       PopupMediaPlayer(NULL);
@@ skipping 18 matching lines @@
 
 MediaPlayer::MediaPlayer()
     : current_position_(0),
       pending_playback_request_(false),
       playlist_browser_(NULL),
       mediaplayer_browser_(NULL) {
   for (size_t i = 0; i < arraysize(supported_mime_type_list); ++i) {
     supported_mime_types_.insert(supported_mime_type_list[i]);
   }
 };