Auto merge of #11140 - asajeffrey:webdriver-pipeline-wait-for-document-ready, r=jgraham

When webdriver is getting a pipeline id, it should wait for the pipeline document to be ready

Thank you for contributing to Servo! Please add an `X` inside each `[ ]` when the step is complete, and replace `__` with appropriate data:
- [X] `./mach build` does not report any errors
- [X] `./mach test-tidy` does not report any errors
- [X] These changes fix #11117 (github issue number if applicable).

Either:
- [ ] There are tests for these changes OR
- [X] These changes do not require tests because they only impact webdriver

Pull requests that do not address these steps are welcome, but they will require additional verification as part of the review process.

<!-- Reviewable:start -->
---
This change is [<img src="https://reviewable.io/review_button.svg" height="35" align="absmiddle" alt="Reviewable"/>](https://reviewable.io/reviews/servo/servo/11140)
<!-- Reviewable:end -->

components/compositing/constellation.rs

@@ -1390,14 +1390,17 @@ impl<LTF: LayoutThreadFactory, STF: ScriptThreadFactory> Constellation<LTF, STF>
     }
 
     fn handle_get_pipeline(&mut self, frame_id: Option<FrameId>,
-                           resp_chan: IpcSender<Option<PipelineId>>) {
+                           resp_chan: IpcSender<Option<(PipelineId, bool)>>) {
         let current_pipeline_id = frame_id.or(self.root_frame_id)
             .and_then(|frame_id| self.frames.get(&frame_id))
             .map(|frame| frame.current);
-        let pipeline_id = self.pending_frames.iter().rev()
+        let current_pipeline_id_loaded = current_pipeline_id
+            .map(|id| (id, true));
+        let pipeline_id_loaded = self.pending_frames.iter().rev()
             .find(|x| x.old_pipeline_id == current_pipeline_id)
-            .map(|x| x.new_pipeline_id).or(current_pipeline_id);
-        if let Err(e) = resp_chan.send(pipeline_id) {
+            .map(|x| (x.new_pipeline_id, x.document_ready))
+            .or(current_pipeline_id_loaded);
+        if let Err(e) = resp_chan.send(pipeline_id_loaded) {
             warn!("Failed get_pipeline response ({}).", e);
         }
     }

components/compositing/lib.rs

@@ -88,8 +88,9 @@ pub enum CompositorMsg {
     /// with the provided pipeline id
     GetFrame(PipelineId, IpcSender<Option<FrameId>>),
     /// Request that the constellation send the current pipeline id for the provided frame
-    /// id, or for the root frame if this is None, over a provided channel
-    GetPipeline(Option<FrameId>, IpcSender<Option<PipelineId>>),
+    /// id, or for the root frame if this is None, over a provided channel.
+    /// Also returns a boolean saying whether the document has finished loading or not.
+    GetPipeline(Option<FrameId>, IpcSender<Option<(PipelineId, bool)>>),
     /// Requests that the constellation inform the compositor of the title of the pipeline
     /// immediately.
     GetPipelineTitle(PipelineId),

components/webdriver_server/lib.rs

@@ -223,32 +223,31 @@ impl Handler {
         }
     }
 
-    fn root_pipeline(&self) -> WebDriverResult<PipelineId> {
+    fn pipeline(&self, frame_id: Option<FrameId>) -> WebDriverResult<PipelineId> {
         let interval = 20;
         let iterations = 30_000 / interval;
+        let (sender, receiver) = ipc::channel().unwrap();
 
         for _ in 0..iterations {
-            if let Some(x) = self.pipeline(None) {
-                return Ok(x)
-            };
-
+            let msg = ConstellationMsg::GetPipeline(frame_id, sender.clone());
+            self.constellation_chan.send(msg).unwrap();
+            // Wait until the document is ready before returning the pipeline id.
+            if let Some((x, true)) = receiver.recv().unwrap() {
+                return Ok(x);
+            }
             thread::sleep(Duration::from_millis(interval));
-        };
+        }
 
         Err(WebDriverError::new(ErrorStatus::Timeout,
-                                "Failed to get root window handle"))
+                                "Failed to get window handle"))
+    }
+
+    fn root_pipeline(&self) -> WebDriverResult<PipelineId> {
+        self.pipeline(None)
     }
 
     fn frame_pipeline(&self) -> WebDriverResult<PipelineId> {
-        if let Some(ref session) = self.session {
-            match self.pipeline(session.frame_id) {
-                Some(x) => Ok(x),
-                None => Err(WebDriverError::new(ErrorStatus::NoSuchFrame,
-                                                "Frame got closed"))
-            }
-        } else {
-            panic!("Command tried to access session but session is None");
-        }
+        self.pipeline(self.session.as_ref().and_then(|session| session.frame_id))
     }
 
     fn session(&self) -> WebDriverResult<&WebDriverSession> {
@@ -270,14 +269,6 @@ impl Handler {
         }
     }
 
-    fn pipeline(&self, frame_id: Option<FrameId>) -> Option<PipelineId> {
-        let (sender, receiver) = ipc::channel().unwrap();
-        self.constellation_chan.send(ConstellationMsg::GetPipeline(frame_id, sender)).unwrap();
-
-
-        receiver.recv().unwrap()
-    }
-
     fn handle_new_session(&mut self) -> WebDriverResult<WebDriverResponse> {
         if self.session.is_none() {
             let session = WebDriverSession::new();