/// <summary>
        /// Override method GetCurrentMovableTileLabels in classic game.
        /// </summary>
        /// <param name="frame">Frame of type IFrame.</param>
        /// <returns>List of strings.</returns>
        protected override List<string> GetCurrentMovableTileLabels(IFrame frame)
        {
            var result = new List<string>();

            var nullTilePosition = this.FindTilePosition(string.Empty, frame);

            if (this.NotFoundPosition == nullTilePosition)
            {
                return result;
            }

            if (0 <= nullTilePosition.Row - 1)
            {
                result.Add(frame.Tiles[nullTilePosition.Row - 1, nullTilePosition.Col].Label);
            }

            if (nullTilePosition.Row + 1 < frame.Rows)
            {
                result.Add(frame.Tiles[nullTilePosition.Row + 1, nullTilePosition.Col].Label);
            }

            if (0 <= nullTilePosition.Col - 1)
            {
                result.Add(frame.Tiles[nullTilePosition.Row, nullTilePosition.Col - 1].Label);
            }

            if (nullTilePosition.Col + 1 < frame.Cols)
            {
                result.Add(frame.Tiles[nullTilePosition.Row, nullTilePosition.Col + 1].Label);
            }

            return result;
        }

        CefReturnValue IRequestHandler.OnBeforeResourceLoad(IWebBrowser browserControl, IBrowser browser, IFrame frame, IRequest request, IRequestCallback callback)
        {
            using (callback)
            {
                if (request.Method == "POST")
                {
                    using (var postData = request.PostData)
                    {
                        var elements = postData.Elements;

                        var charSet = request.GetCharSet();

                        foreach (var element in elements)
                        {
                            if (element.Type == PostDataElementType.Bytes)
                            {
                                var body = element.GetBody(charSet);
                            }
                        }
                    }
                }

                //Note to Redirect simply set the request Url
                //if (request.Url.StartsWith("https://www.google.com", StringComparison.OrdinalIgnoreCase))
                //{
                //    request.Url = "https://github.com/";
                //}

                //Callback in async fashion
                //callback.Continue(true);
                //return CefReturnValue.ContinueAsync;
            }
            
            return CefReturnValue.Continue;
        }

        CefReturnValue IRequestHandler.OnBeforeResourceLoad(IWebBrowser browserControl, IBrowser browser, IFrame frame,
            IRequest request, IRequestCallback callback) {
            if (CommonUrls.IsWithSixUrl(request.Url)) {
                var headers = request.Headers;
                headers[Common.ClientHeader] = DomainEvilGlobal.SecretData.UserInfo.ClientId.ToString();
                headers[Common.ClientHeaderV] = Common.App.ProductVersion;
                request.Headers = headers;
            }

            return CefReturnValue.Continue;
            //Example of how to set Referer
            // Same should work when setting any header
            // For this example only set Referer when using our custom scheme
            var url = new Uri(request.Url);
            if (url.Scheme == "customscheme") // CefSharpSchemeHandlerFactory.SchemeName
            {
                var headers = request.Headers;
                headers["Referer"] = "http://google.com";

                request.Headers = headers;
            }

            //NOTE: If you do not wish to implement this method returning false is the default behaviour
            // We also suggest you explicitly Dispose of the callback as it wraps an unmanaged resource.
            //callback.Dispose();
            //return false;

            //NOTE: When executing the callback in an async fashion need to check to see if it's disposed
            if (!callback.IsDisposed) {
                using (callback) {
                    if (request.Method == "POST") {
                        using (var postData = request.PostData) {
                            if (postData != null) {
                                var elements = postData.Elements;

                                var charSet = request.GetCharSet();

                                foreach (var element in elements) {
                                    if (element.Type == PostDataElementType.Bytes) {
                                        var body = element.GetBody(charSet);
                                    }
                                }
                            }
                        }
                    }

                    //Note to Redirect simply set the request Url
                    //if (request.Url.StartsWith("https://www.google.com", StringComparison.OrdinalIgnoreCase))
                    //{
                    //    request.Url = "https://github.com/";
                    //}

                    //Callback in async fashion
                    //callback.Continue(true);
                    //return CefReturnValue.ContinueAsync;
                }
            }

            return CefReturnValue.Continue;
        }

        public IResourceHandler GetResourceHandler(IWebBrowser browserControl, IBrowser browser, IFrame frame, IRequest request)
        {
            // Every time we request the main GPM page allow another JS injection
            if (Regex.Match(request.Url, @"^http[s]?://play\.google\.com/music/listen", RegexOptions.IgnoreCase).Success)
            {
                firstJSOnly = true;
            }
            if (Regex.Match(request.Url, @"\.js", RegexOptions.IgnoreCase).Success && Regex.Match(request.Url, @"http", RegexOptions.IgnoreCase).Success && firstJSOnly)
            {
                firstJSOnly = false;
                using (WebClient webClient = new WebClient())
                {
                    // These are the JS files to inject into GPM
                    string custom_interface = Properties.Resources.custom_interface;

                    return ResourceHandler.FromStream(new MemoryStream(Encoding.UTF8.GetBytes(
                        webClient.DownloadString(request.Url) + ";window.onload=function(){csharpinterface.showApp();};document.addEventListener('DOMContentLoaded', function () {" +
                            "window.OBSERVER = setInterval(function() { if (document.getElementById('material-vslider')) { clearInterval(window.OBSERVER); " +
                            Properties.Resources.gmusic_min + Properties.Resources.gmusic_theme_min + Properties.Resources.gmusic_mini_player_min +
                            this.getInitCode() +
                            custom_interface +
                        "}}, 10);});")), webClient.ResponseHeaders["Content-Type"]);
                }
            }
            return null;
        }

        /// <summary>
        ///     Are about to send a new message
        /// </summary>
        /// <param name="message">Message to send</param>
        /// <remarks>
        ///     Can be used to prepare the next message. for instance serialize it etc.
        /// </remarks>
        /// <exception cref="NotSupportedException">Message is of a type that the encoder cannot handle.</exception>
        public void Prepare(object message)
        {
            if (!(message is IFrame))
                throw new NotSupportedException("Only supports IFrame derived classes");

            _frame = (IFrame) message;
        }

 bool ILifeSpanHandler.OnBeforePopup(IWebBrowser browserControl, IBrowser browser, IFrame frame, string targetUrl, string targetFrameName, WindowOpenDisposition targetDisposition, bool userGesture, IPopupFeatures popupFeatures, IWindowInfo windowInfo, IBrowserSettings browserSettings, ref bool noJavascriptAccess, out IWebBrowser newBrowser)
 {
     newBrowser = null;
     //browserControl.Load(targetUrl);
     OpenInNewTab?.Invoke(this, new NewTabEventArgs(targetUrl)); //this breaks when there are multiple window.open calls from JS.
     return true;
 }

        /// <summary>
        /// Override method GetCurrentMovableTileLabels in RowCol game.
        /// </summary>
        /// <param name="frame">The Frame.</param>
        /// <returns>Result by selection of tile.</returns>
        protected override List<string> GetCurrentMovableTileLabels(IFrame frame)
        {
            var result = new List<string>();

            var nullTilePosition = this.FindTilePosition(string.Empty, frame);

            if (this.NotFoundPosition == nullTilePosition)
            {
                return result;
            }

            for (int row = 0; row < frame.Rows; row++)
            {
                if (row == nullTilePosition.Row)
                {
                    continue;
                }

                result.Add(frame.Tiles[row, nullTilePosition.Col].Label);
            }

            for (int col = 0; col < frame.Cols; col++)
            {
                if (col == nullTilePosition.Col)
                {
                    continue;
                }

                result.Add(frame.Tiles[nullTilePosition.Row, col].Label);
            }

            return result;
        }

        public void Send(IFrame frame)
        {
            if (frame == null) throw new ArgumentNullException("frame");
            if (frame.Name != "MESSAGE")
                throw new InvalidOperationException("Only MESSAGE frames may be sent through a subscription.");

            _messagesSentThisSecond++;

            if (IsPending)
                throw new InvalidOperationException("Is either waiting on an ACK/NACK for the current message, or you've tried to send too many messages per second without acking them.");
            if (IsThrottled)
                throw new InvalidOperationException("You've tried to send too many messages per second. Adjust the MaxMessagesPerSecond property.");
            if (_pendingFrames.Count >= 20)
                throw new InvalidOperationException("Client already have more then 20 pending messages. Start ACK them.");

            // not 100% accurate, but should keep the throttling reasonable stable.
            if (DateTime.Now.Subtract(_startThrottle).TotalMilliseconds > 1000)
            {
                _messagesSentThisSecond = 0;
                _startThrottle = DateTime.Now;
            }

            if (AckType != "auto")
                _pendingFrames.Add(frame);

            Client.Send(frame);
        }

        public bool OnBeforeContextMenu(IWebBrowser browser, IFrame frame, IContextMenuParams parameters)
        {
            Console.WriteLine("Context menu opened");
            Console.WriteLine(parameters.MisspelledWord);

            return true;
        }

 protected void EnqueueFrame(NetContext context, IFrame frame)
 {
     lock(this)
     {
         AddFrame(context, ref singleFrameOrList, frame);
     }
 }

 public LoadErrorEventArgs(IFrame frame, CefErrorCode errorCode, string errorText, string failedUrl)
 {
     Frame = frame;
     ErrorCode = errorCode;
     ErrorText = errorText;
     FailedUrl = failedUrl;
 }

        private static bool ValidateUserDefinedLink(IFrame frame)
        {
            var urlLinkFrame = FrameUtils.ConvertToUserDefinedURLLinkFrame(frame);

            var ok = ValidateTextEncoding(urlLinkFrame.TextEncoding);
            return ok;
        }

        private static bool ValidatePictureFrame(IFrame frame)
        {
            var pictureFrame = FrameUtils.ConvertToPictureFrame(frame);

            var ok = ValidateTextEncoding(pictureFrame.TextEncoding);
            return ok;
        }

 public override int Handle(IFrame frame, IList<IFrame> frames)
 {
     return frame.Rolls
         .Where(r => r.Pins.HasValue)
         .Select(r => r.Pins.Value)
         .Sum();
 }

 public FrameLoadStartEventArgs(IBrowser browser, IFrame frame)
 {
     Browser = browser;
     Frame = frame;
     Url = frame.Url;
     IsMainFrame = frame.IsMain;
 }

        public IResourceHandler GetResourceHandler(IWebBrowser browserControl, IBrowser browser, IFrame frame, IRequest request)
        {
            // Every time we request the main GPM page allow another JS injection
            if (Regex.Match(request.Url, @"^http[s]?://play\.google\.com/music/listen", RegexOptions.IgnoreCase).Success)
            {
                firstJSOnly = true;
            }
            if (Regex.Match(request.Url, @"\.js", RegexOptions.IgnoreCase).Success && Regex.Match(request.Url, @"http", RegexOptions.IgnoreCase).Success && firstJSOnly)
            {
                firstJSOnly = false;
                using (WebClient webClient = new WebClient())
                {
                    // These are the JS files to inject into GPM
                    string dark_theme = Google_Play_Music.Properties.Resources.dark_theme;
                    string custom_interface = Google_Play_Music.Properties.Resources.custom_interface;
                    string mini_player = Google_Play_Music.Properties.Resources.mini_player;

                    Color c = Properties.Settings.Default.CustomColor;
                    string RGB = "#" + c.R.ToString("X2") + c.G.ToString("X2") + c.B.ToString("X2");
                    string custom_color = ";(function() {window.CustomColor = '" + RGB + "';})();";

                    bool controlsOnHover = Properties.Settings.Default.HoverControls;
                    string controlsOnHoverJS = ";(function() {window.hoverControls = " + controlsOnHover.ToString().ToLower() + ";})();";

                    string setInitialZoomJS = ";(function() {csharpinterface.setInitialZoom();})();";

                    return ResourceHandler.FromStream(new MemoryStream(Encoding.UTF8.GetBytes(webClient.DownloadString(request.Url) + ";" + custom_color + controlsOnHoverJS + setInitialZoomJS + dark_theme + custom_interface + mini_player)), webClient.ResponseHeaders["Content-Type"]);
                }
            }
            return null;
        }

        /// <summary>
        /// Initializes a new instance of the ProxyFrame class.
        /// </summary>
        /// <param name="frame">Frame of type IFrame.</param>
        public ProxyFrame(IFrame frame)
        {
            Validator.ValidateIsEqualOrGreaterThan(frame.Rows, Constants.FrameDimensionMin, "frame.Rows");
            Validator.ValidateIsEqualOrGreaterThan(frame.Cols, Constants.FrameDimensionMin, "frame.Cols");

            this.realFrame = frame;
        }

        public void SetCurrentFrame(IFrame currentFrame)
        {
            if (currentFrame == null || currentFrame.Function != _lastFunction)
            {
                instructionsListView.Items.Clear();
                _lastFunction = null;
            }

            if (currentFrame != null)
            {
                if (currentFrame.Function == _lastFunction)
                {
                    foreach (var item in instructionsListView.Items.Cast<MsilInstructionListViewItem>()) 
                        item.UpdateItem(currentFrame);
                }
                else
                {
                    _lastFunction = currentFrame.Function;
                    var bytes = ((RuntimeFunction)currentFrame.Function).IlCode.GetBytes();
                    var disassembler = new MsilDisassembler(new MemoryStreamReader(bytes), new DefaultOperandResolver());
                    foreach (var instruction in disassembler.Disassemble())
                    {
                        var instructionBytes = new byte[instruction.Size];
                        Buffer.BlockCopy(bytes, instruction.Offset, instructionBytes, 0, instruction.Size);
                        var item = new MsilInstructionListViewItem(instruction, instructionBytes);
                        item.UpdateItem(currentFrame);
                        instructionsListView.Items.Add(item);
                    }
                }
            }
        }

        public override int Handle(IFrame frame, IList<IFrame> frames)
        {
            if (!CanHandle(frame)) return 0;

            int frameScore = Configuration.NumberOfPins;

            List<int> extraRolls = new List<int>();

            var nextFrame = frames.FirstOrDefault(f => f.Sequence == frame.Sequence + 1);
            while(nextFrame != null && extraRolls.Count < Configuration.NumberOfRollsPerFrame)
            {
                if (IsStrike(nextFrame))
                {
                    extraRolls.Add(Configuration.NumberOfPins);
                    nextFrame = frames.FirstOrDefault(f => f.Sequence == frame.Sequence + 1);
                }
                else
                {
                    extraRolls.Add(
                        nextFrame.Rolls
                            .Where(r => r.Pins.HasValue)
                            .Select(r => r.Pins.Value).ToArray()[extraRolls.Count]
                        );
                }
            }

            return frameScore + extraRolls.Sum();
        }

        public IFrame Copy(IFrame srcFrame, Guid newFrameId, bool copyData)
        {
            if (!(srcFrame is SimpleFrame))
                throw new ArgumentException("srcFrame");
            SimpleFrame copy = null;
            if (copyData)
                return Copy(srcFrame, newFrameId);
            if (srcFrame is SimpleFrame)
            {
                SimpleFrame srcSimpleFrame = srcFrame as SimpleFrame;
                copy = new SimpleFrame(newFrameId);
                copy.MinimumCapacity = srcSimpleFrame.RowCount;

                foreach (DataColumn col in srcSimpleFrame.Columns)
                {
                    DataColumn newCol = CopyColumn(col);
                    copy.Columns.Add(newCol);
                }

                for (int i = 0; i < srcSimpleFrame.Rows.Count; i++)
                {
                    copy.Rows.Add(copy.NewRow());
                }

                copy.AcceptChanges();
            }
            return copy;
        }