Chrome OS: avoid suspending on lid close when casting is active.

chrome/browser/media/media_capture_devices_dispatcher.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/media/media_capture_devices_dispatcher.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
@@ skipping 87 matching lines @@
   const std::string hexencoded_origin_hash =
       base::HexEncode(origin_hash.data(), origin_hash.length());
   return
       hexencoded_origin_hash == "3C2705BC432E7C51CA8553FDC5BEE873FF2468EE" ||
       hexencoded_origin_hash == "50F02B8A668CAB274527D58356F07C2143080FCC";
 #else
   return false;
 #endif
 }
 
+#if defined(OS_CHROMEOS)
+// Returns true of the security origin is associated with casting.
+bool IsOriginForCasting(const GURL& origin) {
+#if defined(OFFICIAL_BUILD)
+  // Whitelisted tab casting extensions.
+  if (origin.spec() == "chrome-extension://pkedcjkdefgpdelpbcmbmeomcjbeemfm/" ||
+      origin.spec() == "chrome-extension://fmfcbgogabcbclcofgocippekhfcmgfj/" ||
+      origin.spec() == "chrome-extension://hfaagokkkhdbgiakmmlclaapfelnkoah/") {
+    return true;
+  }
+  // Check against hashed origins.
+  const std::string origin_hash = base::SHA1HashString(origin.spec());
+  DCHECK_EQ(origin_hash.length(), base::kSHA1Length);
+  const std::string hexencoded_origin_hash =
+      base::HexEncode(origin_hash.data(), origin_hash.length());
+  return
+      hexencoded_origin_hash == "3C2705BC432E7C51CA8553FDC5BEE873FF2468EE" ||

[Sergey Ulanov, 2014/01/17 18:39:32]

These do not need to be hashed anymore. 

[hshi1, 2014/01/17 19:31:28]

Done (removed hash for public release ID; left a TODO for the trusted tester ID)

+      hexencoded_origin_hash == "50F02B8A668CAB274527D58356F07C2143080FCC";
+#else
+  return false;
+#endif
+}
+#endif
+
 // Helper to get title of the calling application shown in the screen capture
 // notification.
 base::string16 GetApplicationTitle(content::WebContents* web_contents,
                                    const extensions::Extension* extension) {
   // Use extension name as title for extensions and origin for drive-by web.
   std::string title;
   if (extension) {
     title = extension->name();
   } else {
     title = web_contents->GetURL().GetOrigin().spec();
@@ skipping 270 matching lines @@
 #endif  // !defined(OS_CHROMEOS)
 
       bool capture_audio =
           (request.audio_type == content::MEDIA_LOOPBACK_AUDIO_CAPTURE &&
            loopback_audio_supported);
 
       // Unless we're being invoked from a component extension, register to
       // display the notification for stream capture.
       bool display_notification = !component_extension;
 
-      ui = GetDevicesForDesktopCapture(devices, screen_id,  capture_audio,
+      ui = GetDevicesForDesktopCapture(devices, screen_id, capture_audio,
                                        display_notification, application_title);
     }
   }
 
   callback.Run(devices, ui.Pass());
 }
 
 void MediaCaptureDevicesDispatcher::ProcessTabCaptureAccessRequest(
     content::WebContents* web_contents,
     const content::MediaStreamRequest& request,
@@ skipping 241 matching lines @@
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&MediaCaptureDevicesDispatcher::UpdateVideoDevicesOnUIThread,
                  base::Unretained(this), devices));
 }
 
 void MediaCaptureDevicesDispatcher::OnMediaRequestStateChanged(
     int render_process_id,
     int render_view_id,
     int page_request_id,
+    const GURL& security_origin,
     const content::MediaStreamDevice& device,
     content::MediaRequestState state) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(
           &MediaCaptureDevicesDispatcher::UpdateMediaRequestStateOnUIThread,
           base::Unretained(this), render_process_id, render_view_id,
-          page_request_id, device, state));
+          page_request_id, security_origin, device, state));
 }
 
 void MediaCaptureDevicesDispatcher::OnAudioStreamPlayingChanged(
     int render_process_id, int render_view_id, int stream_id,
     bool is_playing, float power_dbfs, bool clipped) {
   audio_stream_indicator_->UpdateWebContentsStatus(
       render_process_id, render_view_id, stream_id,
       is_playing, power_dbfs, clipped);
 }
 
@@ skipping 23 matching lines @@
   devices_enumerated_ = true;
   video_devices_ = devices;
   FOR_EACH_OBSERVER(Observer, observers_,
                     OnUpdateVideoDevices(video_devices_));
 }
 
 void MediaCaptureDevicesDispatcher::UpdateMediaRequestStateOnUIThread(
     int render_process_id,
     int render_view_id,
     int page_request_id,
+    const GURL& security_origin,
     const content::MediaStreamDevice& device,
     content::MediaRequestState state) {
   // Track desktop capture sessions.  Tracking is necessary to avoid unbalanced
   // session counts since not all requests will reach MEDIA_REQUEST_STATE_DONE,
   // but they will all reach MEDIA_REQUEST_STATE_CLOSING.
   if (device.type == content::MEDIA_DESKTOP_VIDEO_CAPTURE) {
     if (state == content::MEDIA_REQUEST_STATE_DONE) {
       DesktopCaptureSession session = { render_process_id, render_view_id,
                                         page_request_id };
       desktop_capture_sessions_.push_back(session);
@@ skipping 26 matching lines @@
           queue.erase(it);
           found = true;
           break;
         }
       }
       if (found)
         break;
     }
   }
 
+#if defined(OS_CHROMEOS)
+  if (IsOriginForCasting(security_origin) && IsVideoMediaType(device.type)) {
+    // Notify ash that casting state has changed.
+    if (state == content::MEDIA_REQUEST_STATE_DONE) {
+      ash::Shell::GetInstance()->OnCastingStateChanged(true);
+    } else if (state == content::MEDIA_REQUEST_STATE_CLOSING) {
+      ash::Shell::GetInstance()->OnCastingStateChanged(false);
+    }
+  }
+#endif
+
   FOR_EACH_OBSERVER(Observer, observers_,
                     OnRequestUpdate(render_process_id,
                                     render_view_id,
                                     device,
                                     state));
 }
 
 void MediaCaptureDevicesDispatcher::OnCreatingAudioStreamOnUIThread(
     int render_process_id,
     int render_view_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   FOR_EACH_OBSERVER(Observer, observers_,
                     OnCreatingAudioStream(render_process_id, render_view_id));
 }
 
 bool MediaCaptureDevicesDispatcher::IsDesktopCaptureInProgress() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return desktop_capture_sessions_.size() > 0;
 }